Reintroduce package Generalized map

Generalized_map/examples/Generalized_map/CMakeLists.txt

@@ -0,0 +1,42 @@
+# Created by the script cgal_create_cmake_script
+# This is the CMake script for compiling a CGAL application.
+
+# cmake ../ -DCMAKE_BUILD_TYPE=Debug
+# ou
+# cmake ../ -DCMAKE_BUILD_TYPE=Release
+
+project( GMap_examples )
+
+CMAKE_MINIMUM_REQUIRED(VERSION 2.4.5)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
+set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS true)
+
+SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -w -pedantic -Wextra  -Wall")
+
+if ( COMMAND cmake_policy )
+  cmake_policy( SET CMP0003 NEW )
+endif()
+
+# Pour le problème de valgrind avec CGAL
+# add_definition(-DCGAL_DISABLE_ROUNDING_MATH_CHECK)
+
+find_package(CGAL QUIET COMPONENTS Core )
+
+if ( CGAL_FOUND )
+
+  include( ${CGAL_USE_FILE} )
+
+  include( CGAL_CreateSingleSourceCGALProgram )
+  include_directories(BEFORE ../../include)
+
+  create_single_source_cgal_program( "gmap_3_simple_example.cpp" )
+  create_single_source_cgal_program( "gmap_4_simple_example.cpp" )
+  create_single_source_cgal_program( "gmap_3_with_colored_facets.cpp" )
+  create_single_source_cgal_program( "gmap_3_operations.cpp" )
+  create_single_source_cgal_program( "gmap_3_marks.cpp" )
+else()
+
+    message(STATUS "This program requires the CGAL library, and will not be compiled.")
+
+endif()

Generalized_map/examples/Generalized_map/gmap_3_marks.cpp

@@ -0,0 +1,73 @@
+// Copyright (c) 2010 CNRS, LIRIS, http://liris.cnrs.fr/, 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; version 2.1 of the License.
+// See the file LICENSE.LGPL distributed with CGAL.
+//
+// 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>
+//
+#include <CGAL/Generalized_map.h>
+#include <CGAL/Generalized_map_constructors.h>
+#include <iostream>
+#include <cstdlib>
+
+typedef CGAL::Generalized_map<3> CMap_3;
+typedef CMap_3::Dart_handle Dart_handle;
+
+int main()
+{
+  CMap_3 cm;
+
+  // Reserve a mark
+  int mark = cm.get_new_mark();
+  if ( mark==-1 )
+    {
+      std::cerr<<"No more free mark, exit."<<std::endl;
+      exit(-1);
+    }
+
+  // Create two tetrahedra.
+  Dart_handle dh1 = CGAL::make_combinatorial_tetrahedron(cm);
+  Dart_handle dh2 = CGAL::make_combinatorial_tetrahedron(cm);
+
+  CGAL_assertion( cm.is_valid() );
+  CGAL_assertion( CGAL::is_volume_combinatorial_tetrahedron(cm, dh1) );
+  CGAL_assertion( CGAL::is_volume_combinatorial_tetrahedron(cm, dh2) );
+
+  // 3-sew them.
+  cm.sew<3>(dh1, dh2);
+
+  // Mark the darts belonging to the first tetrahedron.
+  for  (CMap_3::Dart_of_cell_range<3>::iterator
+          it(cm.darts_of_cell<3>(dh1).begin()),
+          itend(cm.darts_of_cell<3>(dh1).end()); it!=itend; ++it)
+    cm.mark(it, mark);
+
+  // Remove the common 2-cell between the two cubes:
+  // the two tetrahedra are merged.
+  //  cm.remove_cell<2>(dh1);
+
+  // Thanks to the mark, we know which darts come from the first tetrahedron.
+  unsigned int res=0;
+  for (CMap_3::Dart_range::iterator it(cm.darts().begin()),
+         itend(cm.darts().end()); it!=itend; ++it)
+  {
+    if ( cm.is_marked(it, mark) )
+      ++res;
+  }
+
+  std::cout<<"Number of darts from the first tetrahedron: "<<res<<std::endl;
+  cm.free_mark(mark);
+
+  return EXIT_SUCCESS;
+}

Generalized_map/examples/Generalized_map/gmap_3_operations.cpp

@@ -0,0 +1,73 @@
+// Copyright (c) 2010 CNRS, LIRIS, http://liris.cnrs.fr/, 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; version 2.1 of the License.
+// See the file LICENSE.LGPL distributed with CGAL.
+//
+// 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>
+//
+#include <CGAL/Generalized_map.h>
+#include <CGAL/Generalized_map_constructors.h>
+#include <iostream>
+#include <cstdlib>
+
+typedef CGAL::Generalized_map<3> CMap_3;
+typedef CMap_3::Dart_handle      Dart_handle;
+
+int main()
+{
+  CMap_3 cm;
+
+  // Create one hexahedron.
+  Dart_handle d1 = CGAL::make_combinatorial_hexahedron(cm);
+  CGAL_assertion( cm.is_valid() );
+  CGAL_assertion( CGAL::is_volume_combinatorial_hexahedron(cm, d1) );
+
+  // Add two edges along two opposite facets.
+  //  CGAL::insert_cell_1_in_cell_2(cm,d1->alpha(1),d1->alpha(0));
+  CGAL_assertion( cm.is_valid() );
+
+  Dart_handle d2=d1->alpha(2)->alpha(1)->alpha(1)->alpha(2);
+  //  CGAL::insert_cell_1_in_cell_2(cm,d2,d2->alpha(1)->alpha(1));
+  CGAL_assertion( cm.is_valid() );
+
+  // Insert a facet along these two new edges plus two initial edges of the cube.
+  std::vector<Dart_handle> path;
+  path.push_back(d1->alpha(1));
+  path.push_back(d1->alpha(0)->alpha(2)->alpha(1));
+  path.push_back(d2->alpha(0));
+  path.push_back(d2->alpha(2)->alpha(1));
+
+  //Dart_handle d3=CGAL::insert_cell_2_in_cell_3(cm,path.begin(),path.end());
+  CGAL_assertion( cm.is_valid() );
+
+  // Display the m characteristics.
+  cm.display_characteristics(std::cout) << ", valid=" <<
+    cm.is_valid() << std::endl;
+
+  // We use the removal operations to get back to the initial cube.
+  //  cm.remove_cell<2>(d3);
+  CGAL_assertion( cm.is_valid() );
+
+  //  cm.remove_cell<1>(d1->alpha(1));
+  CGAL_assertion( cm.is_valid() );
+
+  //  cm.remove_cell<1>(d2->alpha(0));
+  CGAL_assertion( cm.is_valid() );
+
+  // Display the m characteristics.
+  cm.display_characteristics(std::cout) << ", valid="
+					<< cm.is_valid() << std::endl;
+
+  return EXIT_SUCCESS;
+}

Generalized_map/examples/Generalized_map/gmap_3_simple_example.cpp

@@ -0,0 +1,44 @@
+#include <CGAL/Generalized_map.h>
+#include <CGAL/Generalized_map_constructors.h>
+#include <iostream>
+#include <cstdlib>
+
+typedef CGAL::Generalized_map<3> CMap_3;
+typedef CMap_3::Dart_handle Dart_const_handle;
+
+int main()
+{
+  CMap_3 cm;
+
+  // Create two tetrahedra.
+  Dart_const_handle d1 = CGAL::make_combinatorial_tetrahedron(cm);
+  Dart_const_handle d2 = CGAL::make_combinatorial_tetrahedron(cm);
+
+  // Display the map characteristics.
+  cm.display_characteristics(std::cout);
+  std::cout<<", valid="<<cm.is_valid()<<std::endl;
+
+  unsigned int res = 0;
+  // Iterate through all the darts of the first tetrahedron.
+  // Note that CMap_3::Dart_of_orbit_range<1,2> is in 3D equivalent to
+  // CMap_3::Dart_of_cell_range<3>.
+  for (CMap_3::Dart_of_orbit_range<0,1,2>::const_iterator
+         it(cm.darts_of_orbit<0,1,2>(d1).begin()),
+         itend(cm.darts_of_orbit<0,1,2>(d1).end());
+       it!=itend; ++it)
+    ++res;
+
+  std::cout<<"Number of darts of the first tetrahedron: "<<res<<std::endl;
+
+  res = 0;
+  // Iterate through all the darts of the face incident to d1.
+  for (CMap_3::Dart_of_orbit_range<0,1>::const_iterator
+         it(cm.darts_of_orbit<0,1>(d1).begin()),
+         itend(cm.darts_of_orbit<0,1>(d1).end());
+       it!=itend; ++it)
+    ++res;
+
+  std::cout<<"Number of darts of the face incident to d1: "<<res<<std::endl;
+
+  return EXIT_SUCCESS;
+}

Generalized_map/examples/Generalized_map/gmap_3_with_colored_facets.cpp

@@ -0,0 +1,114 @@
+// Copyright (c) 2010 CNRS, LIRIS, http://liris.cnrs.fr/, 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; version 2.1 of the License.
+// See the file LICENSE.LGPL distributed with CGAL.
+//
+// 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>
+//
+#include <CGAL/Generalized_map.h>
+#include <CGAL/Generalized_map_constructors.h>
+#include <CGAL/Cell_attribute.h>
+#include <iostream>
+#include <algorithm>
+#include <cstdlib>
+
+struct Sum_functor
+{
+  template<class Cell_attribute>
+  void operator()(Cell_attribute& ca1,Cell_attribute& ca2)
+  { ca1.info()=ca1.info()+ca2.info(); }
+};
+struct Divide_by_two_functor
+{
+  template<class Cell_attribute>
+  void operator()(Cell_attribute& ca1,Cell_attribute& ca2)
+  {
+    ca1.info()=(ca1.info()/2);
+    ca2.info()=(ca1.info());
+  }
+};
+
+struct Myitem
+{
+  template<class CMap>
+  struct Dart_wrapper
+  {
+    typedef CGAL::GMap_dart<3, CMap> Dart;
+    typedef CGAL::Cell_attribute<CMap, int, CGAL::Tag_true,
+                                 Sum_functor, Divide_by_two_functor>
+    Facet_attribute;
+    typedef CGAL::cpp0x::tuple<void,void,Facet_attribute> Attributes;
+  };
+};
+
+typedef CGAL::Generalized_map<3,Myitem> CMap_3;
+typedef CMap_3::Dart_handle               Dart_handle;
+
+int main()
+{
+  CMap_3 cm;
+
+  // Create 2 cubes.
+  Dart_handle dh1 = CGAL::make_combinatorial_hexahedron(cm);
+  Dart_handle dh2 = CGAL::make_combinatorial_hexahedron(cm);
+
+  // 1) Create all 2-attributes and associated them to darts.
+  for (CMap_3::Dart_range::iterator
+         it=cm.darts().begin(), itend=cm.darts().end();
+       it!=itend; ++it)
+  {
+    if ( it->attribute<2>()==NULL )
+      cm.set_attribute<2>(it, cm.create_attribute<2>());
+  }
+
+  // 2) Set the color of all facets of the first cube to 1
+  for (CMap_3::One_dart_per_incident_cell_range<2, 3>::iterator
+         it=cm.one_dart_per_incident_cell<2,3>(dh1).begin(),
+         itend=cm.one_dart_per_incident_cell<2,3>(dh1).end(); it!=itend; ++it)
+    { it->attribute<2>()->info()=7; }
+
+  // 3) Set the color of all facets of the second cube to 19
+  for (CMap_3::One_dart_per_incident_cell_range<2, 3>::iterator it=
+	 cm.one_dart_per_incident_cell<2,3>(dh2).begin(),
+	 itend=cm.one_dart_per_incident_cell<2,3>(dh2).end(); it!=itend; ++it)
+    { it->attribute<2>()->info()=13; }
+
+  // 4) 3-Sew the two cubes along one facet
+  cm.sew<3>(dh1, dh2);
+
+  // 5) Display all the values of 2-attributes
+  for (CMap_3::Attribute_range<2>::type::iterator
+	 it=cm.attributes<2>().begin(), itend=cm.attributes<2>().end();
+       it!=itend; ++it)
+    {
+      std::cout<<it->info()<<"; ";
+    }
+  std::cout<<std::endl;
+
+  // 6) Barycentric triangulation of one facet of the first cube.
+  //CGAL::insert_cell_0_in_cell_2(cm, dh2);
+
+  // 7) Display all the values of 2-attributes
+  for (CMap_3::Attribute_range<2>::type::iterator
+         it=cm.attributes<2>().begin(), itend=cm.attributes<2>().end();
+       it!=itend; ++it)
+    {
+      std::cout<<it->info()<<"; ";
+    }
+  std::cout<<std::endl;
+  cm.display_characteristics(std::cout);
+  std::cout<<", valid="<<cm.is_valid()<<std::endl;
+
+  return EXIT_SUCCESS;
+}

Generalized_map/examples/Generalized_map/gmap_4_simple_example.cpp

@@ -0,0 +1,41 @@
+// Copyright (c) 2010 CNRS, LIRIS, http://liris.cnrs.fr/, 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; version 2.1 of the License.
+// See the file LICENSE.LGPL distributed with CGAL.
+//
+// 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>
+//
+#include <CGAL/Generalized_map.h>
+#include<CGAL/Generalized_map_constructors.h>
+#include <iostream>
+#include <cstdlib>
+
+typedef CGAL::Generalized_map<4> CMap_4;
+typedef CMap_4::Dart_handle Dart_handle;
+
+int main()
+{
+  CMap_4 cm;
+  Dart_handle d1 = CGAL::make_combinatorial_tetrahedron(cm);
+  Dart_handle d2 = CGAL::make_combinatorial_tetrahedron(cm);
+
+  CGAL_assertion(cm.is_valid());
+
+  cm.sew<4>(d1,d2);
+
+  cm.display_characteristics(std::cout);
+  std::cout<<", valid="<<cm.is_valid()<<std::endl;
+
+  return EXIT_SUCCESS;
+}

Generalized_map/include/CGAL/GMap_cell_const_iterators.h

@@ -0,0 +1,106 @@
+// Copyright (c) 2014 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_GMAP_CELL_CONST_ITERATORS_H
+#define CGAL_GMAP_CELL_CONST_ITERATORS_H 1
+
+#include <CGAL/GMap_cell_iterators.h>
+
+// TODO do all the orbit iterator of any orbit ?
+
+namespace CGAL {
+
+  /** @file GMap_cell_const_iterators.h
+   * The cell const iterators. There are 3 classes:
+   *  - GMap_cell_const_iterator<Map,i,dim>
+   *  - GMap_one_dart_per_incident_cell_const_iterator<Map,Ite,i,dim>
+   *  - GMap_one_dart_per_cell_const_iterator<Map,Ite,i,dim>
+   */
+
+  //****************************************************************************
+  template <typename Map_,unsigned int i,unsigned int dim=Map_::dimension>
+  class GMap_cell_const_iterator: public GMap_cell_iterator<Map_,i,dim,true>
+  {
+  public:
+    typedef GMap_cell_iterator<Map_,i,dim,true> Base;
+    typedef typename Map_::Dart_const_handle Dart_const_handle;
+
+    /// Main constructor.
+    GMap_cell_const_iterator(const Map_& amap,
+                             Dart_const_handle adart):
+      Base(amap,adart)
+    {}
+    /// Constructor from non const version.
+    GMap_cell_const_iterator
+    (const GMap_cell_iterator<Map_,i,dim,false>& it):
+      Base(*const_cast<const Map_*>(it.get_combinatorial_map()),
+           it.get_first_dart())
+    {}
+  };
+  //****************************************************************************
+  template <typename Map_,unsigned int i,unsigned int j,
+            unsigned int dim=Map_::dimension>
+  class GMap_one_dart_per_incident_cell_const_iterator:
+    public GMap_one_dart_per_incident_cell_iterator<Map_,i,j,dim,true>
+  {
+  public:
+    typedef GMap_one_dart_per_incident_cell_iterator<Map_,i,j,dim,true> Base;
+    typedef typename Map_::Dart_const_handle Dart_const_handle;
+
+    /// Main constructor.
+    GMap_one_dart_per_incident_cell_const_iterator(const Map_& amap,
+                                                   Dart_const_handle adart):
+      Base(amap, adart)
+    {}
+    /// Constructor from non const version.
+    GMap_one_dart_per_incident_cell_const_iterator
+    (const GMap_one_dart_per_incident_cell_iterator<Map_,i,j,dim,false>& it):
+      Base(*const_cast<const Map_*>(it.get_combinatorial_map()),
+           it.get_first_dart())
+    {}
+  };
+  //****************************************************************************
+  template <typename Map_,unsigned int i,unsigned int dim=Map_::dimension>
+  class GMap_one_dart_per_cell_const_iterator:
+    public GMap_one_dart_per_cell_iterator<Map_,i,dim,true>
+  {
+  public:
+    typedef GMap_one_dart_per_cell_iterator<Map_,i,dim,true> Base;
+    typedef typename Map_::Dart_const_handle Dart_const_handle;
+
+    /// Main constructor.
+    GMap_one_dart_per_cell_const_iterator(const Map_& amap): Base(amap)
+    {}
+    /// Constructor with a dart in parameter (for end iterator).
+    GMap_one_dart_per_cell_const_iterator(const Map_& amap,
+                                          Dart_const_handle adart):
+      Base(amap)
+    { this->set_current_dart(adart); }
+    /// Constructor from non const version.
+    GMap_one_dart_per_cell_const_iterator
+    (const GMap_one_dart_per_cell_iterator<Map_,i,dim,false>& it):
+      Base(*const_cast<const Map_*>(it.get_combinatorial_map()))
+    {}
+  };
+  //****************************************************************************
+  //****************************************************************************
+} // namespace CGAL
+//******************************************************************************
+#endif // CGAL_GMAP_CELL_CONST_ITERATORS_H
+//******************************************************************************

Generalized_map/include/CGAL/GMap_cell_iterators.h

@@ -0,0 +1,202 @@
+// Copyright (c) 2014 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_GMAP_CELL_ITERATORS_H
+#define CGAL_GMAP_CELL_ITERATORS_H 1
+
+#include <CGAL/Cell_iterators.h>
+
+// TODO do all the orbit iterator of any orbit ?
+
+namespace CGAL {
+
+  /** @file Cell_iterators.h
+   * Cell iterators. There are 3 classes:
+   * * - GMap_cell_iterator<Map,i,dim>: one dart per each i-cell
+   * * - GMap_one_dart_per_incident_cell_iterator<Map,Ite,i,dim>
+   * * - GMap_one_dart_per_cell_iterator<Map,Ite,i,dim>
+   */
+
+  //****************************************************************************
+  /* Class GMap_cell_iterator<Map,i,dim,Tag_false>: to iterate onto
+     * all the cells of the gmap.
+     */
+  template <typename Map_,unsigned int i,unsigned int dim,bool Const>
+  class GMap_cell_iterator: public GMap_dart_iterator_basic_of_all<Map_,Const>
+  {
+  public:
+    typedef GMap_dart_iterator_basic_of_all<Map_,Const> Base;
+    typedef GMap_cell_iterator<Map_,i,dim,Const> Self;
+
+    typedef typename Base::Dart_handle Dart_handle;
+    typedef typename Base::Map Map;
+
+  protected:
+    /// Unmark all the marked darts during the iterator.
+    void unmark_treated_darts()
+    {
+      if (this->mmap->is_whole_map_unmarked(mmark_number)) return;
+
+      this->mmap->negate_mark(mmark_number);
+
+      if (this->mmap->is_whole_map_unmarked(mmark_number)) return;
+
+      Base::rewind();
+      mark_cell<Map,i,dim>(*this->mmap, (*this),
+                           mmark_number);
+      while (this->mmap->number_of_unmarked_darts(mmark_number) > 0)
+        this->operator++();
+      this->mmap->negate_mark(mmark_number);
+      CGAL_assertion(this->mmap->is_whole_map_unmarked(mmark_number));
+    }
+
+  public:
+    /// Main constructor.
+    GMap_cell_iterator(Map& amap):
+      Base(amap),
+      mmark_number(amap.get_new_mark())
+    {
+      CGAL_static_assertion( (boost::is_same<typename Base::Basic_iterator,
+                              Tag_true>::value) );
+      CGAL_assertion(amap.is_whole_map_unmarked(mmark_number));
+      mark_cell<Map,i,dim>(amap, (*this), mmark_number);
+    }
+
+    /// Destructor.
+    ~GMap_cell_iterator()
+    {
+      if (this->mmap->get_number_of_times_mark_reserved(mmark_number)==1)
+        unmark_treated_darts();
+      this->mmap->free_mark(mmark_number);
+    }
+
+    /// Copy constructor.
+    GMap_cell_iterator(const Self& aiterator):
+      Base(aiterator),
+      mmark_number(aiterator.mmark_number)
+    { this->mmap->share_a_mark(mmark_number); }
+
+    /// Assignment operator.
+    Self& operator=(Self& aiterator)
+    {
+      if (this != &aiterator)
+      {
+        Base::operator=(aiterator);
+        mmark_number = aiterator.mmark_number;
+        this->mmap->share_a_mark(mmark_number);
+      }
+      return *this;
+    }
+
+    /// Rewind of the iterator to its beginning.
+    void rewind()
+    {
+      unmark_treated_darts();
+      Base::rewind();
+      mark_cell<Map,i,dim>(*this->mmap, (*this), mmark_number);
+    }
+
+    /// Postfix ++ operator.
+    Self operator++(int)
+    { Self res=*this; operator ++(); return res; }
+
+    /// Prefix ++ operator.
+    Self& operator++()
+    {
+      CGAL_assertion(this->cont());
+      do
+      {
+        Base::operator++();
+      }
+      while (this->cont() &&
+             this->mmap->is_marked((*this), mmark_number));
+
+      if (this->cont())
+        mark_cell<Map,i,dim>(*this->mmap, (*this), mmark_number);
+      return *this;
+    }
+
+  private:
+    /// A mark used to mark treated cells.
+    int mmark_number;
+  };
+  //****************************************************************************
+  /* Class GMap_one_dart_per_incident_cell_iterator<Map,i,j,dim>: to iterate
+   * onto one dart per i-cell incident to the given j-cell.
+   */
+  template <typename Map_,unsigned int i,unsigned int j,
+            unsigned int dim=Map_::dimension,bool Const=false>
+  class GMap_one_dart_per_incident_cell_iterator:
+    public CMap_cell_iterator<Map_,
+                              GMap_dart_iterator_basic_of_cell
+                              <Map_,j,dim,Const>, i,dim,Const>
+  {
+  public:
+    typedef GMap_one_dart_per_incident_cell_iterator<Map_,i,j,dim,Const> Self;
+    typedef CMap_cell_iterator<Map_,
+                               GMap_dart_iterator_basic_of_cell<Map_,j,
+                                                                dim,Const>,
+                               i,dim,Const> Base;
+
+    typedef typename Base::Dart_handle Dart_handle;
+    typedef typename Base::Map Map;
+
+    typedef Tag_false Use_mark;
+    typedef Tag_false Basic_iterator;
+
+    /// Main constructor.
+    GMap_one_dart_per_incident_cell_iterator(Map& amap, Dart_handle adart):
+      Base(amap, adart)
+    {}
+  };
+  //****************************************************************************
+  /* Class GMap_one_dart_per_cell_iterator<Map,i,dim>: to iterate onto the
+   * i-cells incident of the map (one dart by each i-cell).
+   */
+  template <typename Map_,unsigned int i,unsigned int dim=Map_::dimension,
+            bool Const=false>
+  class GMap_one_dart_per_cell_iterator:
+    public CMap_cell_iterator<Map_,GMap_dart_iterator_basic_of_all<Map_,Const>,
+                              i,dim,Const>
+  {
+  public:
+    typedef GMap_one_dart_per_cell_iterator<Map_,i,dim,Const> Self;
+    typedef CMap_cell_iterator<Map_,
+                               GMap_dart_iterator_basic_of_all<Map_,Const>,
+                               i,dim,Const> Base;
+
+    typedef typename Base::Dart_handle Dart_handle;
+    typedef typename Base::Map Map;
+
+    typedef Tag_false Use_mark;
+    typedef Tag_false Basic_iterator;
+
+    /// Main constructor.
+    GMap_one_dart_per_cell_iterator(Map& amap): Base(amap)
+    {}
+    /// Constructor with a dart in parameter (for end iterator).
+    GMap_one_dart_per_cell_iterator(Map& amap, Dart_handle adart): Base(amap)
+    { this->set_current_dart(adart); }
+  };
+//****************************************************************************
+//****************************************************************************
+} // namespace CGAL
+//******************************************************************************
+#endif // CGAL_GMAP_CELL_ITERATORS_H
+//******************************************************************************

Generalized_map/include/CGAL/GMap_dart.h

@@ -0,0 +1,214 @@
+// Copyright (c) 2014 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_GMAP_DART_H
+#define CGAL_GMAP_DART_H 1
+
+#include <CGAL/Compact_container.h>
+#include <CGAL/assertions.h>
+#include <bitset>
+
+namespace CGAL {
+
+/** @file GMap_dart.h
+ * Definition of nD dart for generalized maps.
+ */
+
+  namespace internal {
+    template <typename Map,unsigned int i>
+    struct basic_link_alpha_functor;
+
+    template <typename CMap,unsigned int i>
+    struct link_alpha_functor;
+  }
+
+/** Definition of nD dart.
+ * The GMap_dart class describes an nD dart (basic element of a
+ * generalized map). A dart is composed with handle towards its neighbors,
+ * a bitset containing Boolean marks, and handle towards enabled attributes.
+ * n is the dimension of the space (2 for 2D, 3 for 3D...)
+ * Refs the ref class
+ */
+template <int d, typename Refs>
+struct GMap_dart
+{
+  template < unsigned int, class, class, class, class >
+  friend class Generalized_map_base;
+
+  template < unsigned int, class, class >
+  friend class Generalized_map_storage_1;
+
+  template < unsigned int, class, class >
+  friend class Generalized_map_storage_2;
+
+  template <class, class, class>
+  friend class Compact_container;
+
+  template<class, unsigned int, unsigned int>
+  friend struct Remove_cell_functor;
+
+  template<class, unsigned int>
+  friend struct Contract_cell_functor;
+
+  template <typename, unsigned int>
+  friend struct internal::link_alpha_functor;
+
+public:
+  typedef GMap_dart<d,Refs>                Self;
+  typedef typename Refs::Dart_handle       Dart_handle;
+  typedef typename Refs::size_type         size_type;
+  typedef typename Refs::Dart_const_handle Dart_const_handle;
+  typedef typename Refs::Helper            Helper;
+  /// Typedef for attributes
+  template<int i>
+  struct Attribute_handle: public Refs::template Attribute_handle<i>
+  {};
+  template<int i>
+  struct Attribute_const_handle: public Refs::template Attribute_const_handle<i>
+  {};
+
+   /// The number of used marks.
+   static const size_type NB_MARKS = Refs::NB_MARKS;
+
+   /// The dimension of the generalized map.
+   static const unsigned int dimension = d;
+
+   /** Return the alpha of this dart for a given dimension.
+    * @return alpha(\em i).
+    */
+  template<unsigned int i>
+  Dart_handle alpha()
+  {
+    CGAL_assertion(i <= dimension);
+    return malpha[i];
+  }
+  template<unsigned int i>
+  Dart_const_handle alpha() const
+  {
+    CGAL_assertion(i <= dimension);
+    return malpha[i];
+  }
+  Dart_handle alpha(unsigned int i)
+  {
+    CGAL_assertion(i <= dimension);
+    return malpha[i];
+  }
+  Dart_const_handle alpha(unsigned int i) const
+  {
+    CGAL_assertion(i <= dimension);
+    return malpha[i];
+  }
+
+  /// @return a handle on the i-attribute
+  template<int i>
+  typename Attribute_handle<i>::type attribute()
+  {
+    CGAL_static_assertion_msg( Helper::template Dimension_index<i>::value>=0,
+                               "attribute<i> but i-attributes are disabled.");
+    return CGAL::cpp0x::get<Helper::template Dimension_index<i>::value>
+      (mattribute_handles);
+  }
+  template<int i>
+  typename Attribute_const_handle<i>::type attribute() const
+  {
+    CGAL_static_assertion_msg( Helper::template Dimension_index<i>::value>=0,
+                               "attribute<i> but i-attributes are disabled.");
+    return CGAL::cpp0x::get<Helper::template Dimension_index<i>::value>
+      (mattribute_handles);
+  }
+
+   /** Return the mark value of a given mark number.
+    * @param amark the mark number.
+    * @return the value for this number.
+    */
+   bool get_mark(int amark) const
+   {
+     CGAL_assertion(amark>=0 && (size_type)amark<NB_MARKS);
+      return mmarks[(size_type)amark];
+   }
+
+   /** Set the mark of a given mark number to a given value.
+    * @param amark the mark number.
+    * @param AValue the value.
+    */
+   void set_mark(int amark, bool avalue) const
+   {
+     CGAL_assertion(amark>=0 && (size_type)amark<NB_MARKS);
+     mmarks.set((size_type)amark, avalue);
+   }
+    /** Flip the mark of a given mark number.
+     * @param amark the mark number.
+     */
+    void flip_mark(int amark) const
+    {
+      CGAL_assertion(amark>=0 && (size_type)amark<NB_MARKS);
+      mmarks.flip((size_type)amark);
+    }
+
+   /** Return all the marks of this dart.
+    * @return the marks.
+    */
+   std::bitset<NB_MARKS> get_marks() const
+   { return mmarks; }
+
+   /** Set simultaneously all the marks of this dart to a given value.
+    * @param amarks the value of the marks.
+    */
+   void set_marks(const std::bitset<NB_MARKS>& amarks) const
+   { mmarks = amarks; }
+
+protected:
+    /** Default constructor: no real initialisation,
+     *  because this is done in the generalized map class.
+     */
+    GMap_dart()
+    {}
+
+    /** Copy constructor:
+     * @param adart a dart.
+     */
+    GMap_dart(const GMap_dart& adart) :
+      mmarks(adart.mmarks),
+      mattribute_handles(adart.mattribute_handles)
+    {
+      for (unsigned int i = 0; i <= dimension; ++i)
+        malpha[i] = adart.malpha[i];
+    }
+
+public:
+  void * for_compact_container() const
+  { return malpha[0].for_compact_container(); }
+  void * & for_compact_container()
+  { return malpha[0].for_compact_container(); }
+
+protected:
+   /// Alpha for each dimension +1 (from 0 to dimension).
+   Dart_handle malpha[dimension+1];
+
+   /// Values of Boolean marks.
+   mutable std::bitset<NB_MARKS> mmarks;
+
+  /// Attributes enabled
+   typename Helper::Attribute_handles mattribute_handles;
+};
+
+} // namespace CGAL
+
+#endif // CGAL_GMAP_DART_H //
+// EOF //

Generalized_map/include/CGAL/GMap_dart_const_iterators.h

@@ -0,0 +1,282 @@
+// Copyright (c) 2014 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_GMAP_DART_CONST_ITERATORS_HH
+#define CGAL_GMAP_DART_CONST_ITERATORS_HH 1
+
+#include <CGAL/GMap_dart_iterators.h>
+
+namespace CGAL {
+
+  /** @file GMap_dart_const_iterators.h
+   * Definition of gmap dart const iterators.
+   * There are 7 iterators:
+   *  - GMap_dart_const_iterator_basic_of_orbit<Map,Alpha...>
+   *  - GMap_dart_const_iterator_basic_of_cell<Map,i,d>
+   *  - GMap_dart_const_iterator_basic_of_involution<Map,i,d>
+   *  - GMap_dart_const_iterator_basic_of_all<Map>
+   *  - GMap_dart_const_iterator_of_orbit<Map,Alpha...>
+   *  - GMap_dart_const_iterator_of_cell<Map,i,d>
+   *  - GMap_dart_const_iterator_of_involution<Map,i,d>
+   */
+  //****************************************************************************
+#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
+  template<typename Map_,unsigned int...Alpha>
+  class GMap_dart_const_iterator_basic_of_orbit:
+    public GMap_dart_iterator_basic_of_orbit_generic<Map_,true,Alpha...>
+  {
+  public:
+    typedef GMap_dart_const_iterator_basic_of_orbit<Map_,Alpha...> Self;
+    typedef GMap_dart_iterator_basic_of_orbit_generic<Map_,true,Alpha...> Base;
+
+    typedef typename Map_::Dart_const_handle Dart_const_handle;
+
+    /// Main constructor.
+    GMap_dart_const_iterator_basic_of_orbit(const Map_& amap,
+                                            Dart_const_handle adart):
+      Base(amap,adart)
+    {}
+    /// Main constructor.
+    GMap_dart_const_iterator_basic_of_orbit(const Map_& amap,
+                                            Dart_const_handle adart,
+                                            int amark):
+      Base(amap,adart,amark)
+    {}
+    /// Constructor from non const version.
+    GMap_dart_const_iterator_basic_of_orbit
+    (const GMap_dart_const_iterator_basic_of_orbit<Map_,Alpha...>& it):
+      Base(*const_cast<const Map_*>(it.get_combinatorial_map()),
+           it.get_first_dart(),
+           it.mmark_number)
+    {}
+  };
+  //****************************************************************************
+  template<typename Map_,unsigned int...Alpha>
+  class GMap_dart_const_iterator_of_orbit:
+    public GMap_dart_iterator_of_orbit_generic<Map_,true,Alpha...>
+  {
+  public:
+    typedef GMap_dart_const_iterator_of_orbit<Map_,Alpha...> Self;
+    typedef GMap_dart_iterator_of_orbit_generic<Map_,true,Alpha...> Base;
+
+    typedef typename Map_::Dart_const_handle Dart_const_handle;
+
+    /// Main constructor.
+    GMap_dart_const_iterator_of_orbit(const Map_& amap,
+                                      Dart_const_handle adart):
+      Base(amap,adart)
+    {}
+    /// Constructor from non const version.
+    GMap_dart_const_iterator_of_orbit
+    (const GMap_dart_iterator_of_orbit<Map_,Alpha...>& it):
+      Base(*const_cast<const Map_*>(it.get_combinatorial_map()),
+	   it.get_first_dart())
+    {}
+  };
+#else
+  //****************************************************************************
+  template<typename Map_,int B1=-1,int B2=-1,int B3=-1,int B4=-1,int B5=-1,
+	   int B6=-1,int B7=-1,int B8=-1,int B9=-1>
+    class GMap_dart_const_iterator_basic_of_orbit:
+    public GMap_dart_iterator_basic_of_orbit_generic<Map_,true,B1,B2,B3,B4,
+                                                     B5,B6,B7,B8,B9>
+    {
+    public:
+      typedef GMap_dart_const_iterator_basic_of_orbit<Map_,B1,B2,B3,B4,B5,B6,
+                                                      B7,B8,B9> Self;
+      typedef GMap_dart_iterator_basic_of_orbit_generic<Map_,true,B1,B2,B3,B4,
+                                                        B5,B6,B7,B8,B9> Base;
+
+      typedef typename Map_::Dart_const_handle Dart_const_handle;
+
+      /// Main constructor.
+      GMap_dart_const_iterator_basic_of_orbit(const Map_& amap,
+                                              Dart_const_handle adart):
+        Base(amap,adart)
+      {}
+      /// Main constructor.
+      GMap_dart_const_iterator_basic_of_orbit(const Map_& amap,
+                                              Dart_const_handle adart,
+                                              int amark):
+        Base(amap,adart,amark)
+      {}
+      /// Constructor from non const version.
+      GMap_dart_const_iterator_basic_of_orbit
+      (const GMap_dart_const_iterator_basic_of_orbit<Map_,B1,B2,B3,B4,B5,B6,
+       B7,B8,B9>& it):
+        Base(*const_cast<const Map_*>(it.get_combinatorial_map()),
+             it.get_first_dart(),
+             it.mmark_number)
+      {}
+    };
+  //****************************************************************************
+  template<typename Map_,int B1=-1,int B2=-1,int B3=-1,int B4=-1,int B5=-1,
+	   int B6=-1,int B7=-1,int B8=-1,int B9=-1>
+    class GMap_dart_const_iterator_of_orbit:
+    public GMap_dart_iterator_of_orbit_generic<Map_,true,B1,B2,B3,B4,
+                                               B5,B6,B7,B8,B9>
+    {
+    public:
+      typedef GMap_dart_const_iterator_of_orbit<Map_,B1,B2,B3,B4,B5,B6,
+                                                B7,B8,B9> Self;
+      typedef GMap_dart_iterator_of_orbit_generic<Map_,true,B1,B2,B3,B4,
+                                                  B5,B6,B7,B8,B9> Base;
+
+      typedef typename Map_::Dart_const_handle Dart_const_handle;
+
+      /// Main constructor.
+      GMap_dart_const_iterator_of_orbit(const Map_& amap,
+                                        Dart_const_handle adart):
+        Base(amap,adart)
+      {}
+      /// Constructor from non const version.
+      GMap_dart_const_iterator_of_orbit
+      (const GMap_dart_iterator_of_orbit<Map_,B1,B2,B3,B4,B5,B6,B7,B8,B9>& it):
+        Base(*const_cast<const Map_*>(it.get_combinatorial_map()),
+             it.get_first_dart())
+      {}
+    };
+#endif // CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
+  //****************************************************************************
+  template<typename Map_>
+  class GMap_dart_const_iterator_basic_of_all:
+    public GMap_dart_iterator_basic_of_all<Map_,true>
+  {
+  public:
+    typedef GMap_dart_iterator_basic_of_all<Map_,true> Base;
+    typedef typename Map_::Dart_const_handle Dart_const_handle;
+
+    /* Main constructor. */
+    GMap_dart_const_iterator_basic_of_all(const Map_& amap,
+                                          Dart_const_handle adart):
+      Base(amap,adart)
+    {}
+    /* Main constructor. */
+    GMap_dart_const_iterator_basic_of_all(const Map_& amap,
+                                          Dart_const_handle adart,
+                                          int /*amark*/):
+      Base(amap,adart)
+    {}
+    /// Constructor from non const version.
+    GMap_dart_const_iterator_basic_of_all
+    (const GMap_dart_iterator_basic_of_all<Map_,false>& it):
+      Base(*const_cast<const Map_*>(it.get_combinatorial_map()),
+           it.get_first_dart())
+    {}
+  };
+  //****************************************************************************
+  template<typename Map_,int i,int d=Map_::dimension>
+  class GMap_dart_const_iterator_basic_of_cell:
+    public GMap_dart_iterator_basic_of_cell<Map_,i,d,true>
+  {
+  public:
+    typedef GMap_dart_iterator_basic_of_cell<Map_,i,d,true> Base;
+    typedef typename Map_::Dart_const_handle Dart_const_handle;
+
+    /* Main constructor. */
+    GMap_dart_const_iterator_basic_of_cell(const Map_& amap,
+                                           Dart_const_handle adart):
+      Base(amap,adart)
+    {}
+    /* Main constructor. */
+    GMap_dart_const_iterator_basic_of_cell(const Map_& amap,
+                                           Dart_const_handle adart, int amark):
+      Base(amap,adart,amark)
+    {}
+    /// Constructor from non const version.
+    GMap_dart_const_iterator_basic_of_cell
+    (const GMap_dart_iterator_basic_of_cell<Map_,i,d,false>& it):
+      Base(*const_cast<const Map_*>(it.get_combinatorial_map()),
+           it.get_first_dart())
+    {}
+  };
+  //****************************************************************************
+  template<typename Map_, int i, int d=Map_::dimension>
+  class GMap_dart_const_iterator_of_cell:
+    public GMap_dart_iterator_of_cell<Map_,i,d,true>
+  {
+  public:
+    typedef GMap_dart_iterator_of_cell<Map_,i,d,true> Base;
+    typedef typename Map_::Dart_const_handle Dart_const_handle;
+
+    /* Main constructor. */
+    GMap_dart_const_iterator_of_cell(const Map_& amap,
+				     Dart_const_handle adart):
+      Base(amap,adart)
+    {}
+    /// Constructor from non const version.
+    GMap_dart_const_iterator_of_cell
+    (const GMap_dart_iterator_of_cell<Map_,i,d,false>& it):
+      Base(*const_cast<const Map_*>(it.get_combinatorial_map()),
+	   it.get_first_dart())
+    {}
+  };
+  //****************************************************************************
+  template<typename Map_,int i,int d=Map_::dimension>
+  class GMap_dart_const_iterator_basic_of_involution:
+    public GMap_dart_iterator_basic_of_involution<Map_,i,d,true>
+  {
+  public:
+    typedef GMap_dart_iterator_basic_of_involution<Map_,i,d,true> Base;
+    typedef typename Map_::Dart_const_handle Dart_const_handle;
+
+    /* Main constructor. */
+    GMap_dart_const_iterator_basic_of_involution(const Map_& amap,
+						 Dart_const_handle adart):
+      Base(amap,adart)
+    {}
+    /* Main constructor. */
+    GMap_dart_const_iterator_basic_of_involution(const Map_& amap,
+						 Dart_const_handle adart,
+						 int amark):
+      Base(amap,adart,amark)
+    {}
+    /// Constructor from non const version.
+    GMap_dart_const_iterator_basic_of_involution
+    (const GMap_dart_iterator_basic_of_involution<Map_,i,d,false>& it):
+      Base(*const_cast<const Map_*>(it.get_combinatorial_map()),
+	   it.get_first_dart(), it.mmark_number)
+    {}
+  };
+  //****************************************************************************
+  template<typename Map_,int i,int d=Map_::dimension>
+  class GMap_dart_const_iterator_of_involution:
+    public GMap_dart_iterator_of_involution<Map_,i,d,true>
+  {
+  public:
+    typedef GMap_dart_iterator_of_involution<Map_,i,d,true> Base;
+    typedef typename Map_::Dart_const_handle Dart_const_handle;
+
+    /* Main constructor. */
+    GMap_dart_const_iterator_of_involution(const Map_& amap,
+					   Dart_const_handle adart):
+      Base(amap,adart)
+    {}
+    /// Constructor from non const version.
+    GMap_dart_const_iterator_of_involution
+    (const GMap_dart_iterator_of_involution<Map_,i,d,false>& it):
+      Base(*const_cast<const Map_*>(it.get_combinatorial_map()),
+	   it.get_first_dart())
+    {}
+  };
+  //****************************************************************************
+} // namespace CGAL
+//******************************************************************************
+#endif // CGAL_GMAP_DART_CONST_ITERATORS_HH
+//******************************************************************************

Generalized_map/include/CGAL/Generalized_map_constructors.h

@@ -0,0 +1,291 @@
+// Copyright (c) 2014 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_GENERALIZED_MAP_CONSTRUCTORS_H
+#define CGAL_GENERALIZED_MAP_CONSTRUCTORS_H 1
+
+#include <CGAL/Combinatorial_map_basic_operations.h>
+
+namespace CGAL {
+
+  /** @file Generalized_map_constructors.h
+   * Basic creation operations  for a generalized map.
+   * Create edge, triangle, quadrilateral, tetrahedron, hexahedron.
+   */
+
+  /** Create an edge.
+   * @param amap the used generalized map.
+   * @return a dart of the new edge.
+   */
+  template < class Map >
+  typename Map::Dart_handle make_edge(Map& amap)
+  {
+    typename Map::Dart_handle d1 = amap.create_dart();
+    typename Map::Dart_handle d2 = amap.create_dart();
+    amap.basic_link_alpha(d1, d2, 0);
+    return d1;
+  }
+
+  /** Create a combinatorial polygon of length alg
+   * (a cycle of alg edges alpha1 links together).
+   * @param amap the used generalized map.
+   * @return a new dart.
+   */
+  template < class Map >
+  typename Map::Dart_handle make_combinatorial_polygon(Map& amap,
+                                                       unsigned int alg)
+  {
+    CGAL_assertion(alg>0);
+
+    typename Map::Dart_handle start = make_edge(amap);
+    typename Map::Dart_handle prev = amap.template alpha<0>(start);
+    for ( unsigned int nb=1; nb<alg; ++nb )
+    {
+      typename Map::Dart_handle cur = make_edge(amap);
+      amap.template basic_link_alpha<1>(prev, cur);
+      prev=amap.template alpha<0>(cur);
+    }
+
+    amap.template basic_link_alpha<1>(prev, start);
+    return start;
+  }
+
+/** Test if a face is a combinatorial polygon of length alg
+ *  (a cycle of alg darts beta1 links together).
+ * @param amap the used generalized map.
+ * @param adart an intial dart
+ * @return true iff the face containing adart is a polygon of length alg.
+ */
+template < class Map >
+bool is_face_combinatorial_polygon(const Map& amap,
+                                   typename Map::Dart_const_handle adart,
+                                   unsigned int alg)
+{
+  CGAL_assertion(alg>0);
+
+  unsigned int nb = 0;
+  typename Map::Dart_const_handle cur = adart;
+  do
+  {
+    ++nb;
+    if ( amap.is_free(cur, 0) || amap.is_free(amap.alpha(cur, 0), 1) )
+      return false; // Open face
+    cur = amap.alpha(cur,0,1);
+  }
+  while( cur!=adart );
+  return (nb==alg);
+}
+
+  /** Create a combinatorial tetrahedron from 4 triangles.
+   * @param amap the used generalized map.
+   * @param d1 a dart onto a first triangle.
+   * @param d2 a dart onto a second triangle.
+   * @param d3 a dart onto a third triangle.
+   * @param d4 a dart onto a fourth triangle.
+   * @return a new dart.
+   */
+  template < class Map >
+  typename Map::Dart_handle
+  make_combinatorial_tetrahedron(Map& amap,
+                                 typename Map::Dart_handle d1,
+                                 typename Map::Dart_handle d2,
+                                 typename Map::Dart_handle d3,
+                                 typename Map::Dart_handle d4)
+  {
+    amap.template topo_sew<2>(d1, d2);
+    amap.template topo_sew<2>(d3, amap.alpha(d2, 1));
+    amap.template topo_sew<2>(amap.alpha(d1, 1), amap.alpha(d3, 1));
+    amap.template topo_sew<2>(d4, amap.alpha(d2, 0, 1));
+    amap.template topo_sew<2>(amap.alpha(d4, 0, 1), amap.alpha(d3, 0, 1));
+    amap.template topo_sew<2>(amap.alpha(d4, 1), amap.alpha(d1, 0, 1));
+
+    return d1;
+  }
+
+/** Test if a volume is a combinatorial tetrahedron.
+ * @param amap the used generalized map.
+ * @param adart an intial dart
+ * @return true iff the volume containing adart is a combinatorial tetrahedron.
+ */
+template < class Map >
+bool is_volume_combinatorial_tetrahedron(const Map& amap,
+                                         typename Map::Dart_const_handle d1)
+{
+  typename Map::Dart_const_handle d2 = amap.alpha(d1, 2);
+  typename Map::Dart_const_handle d3 = amap.alpha(d2, 1, 2);
+  typename Map::Dart_const_handle d4 = amap.alpha(d2, 0, 1, 2);
+
+  if ( !is_face_combinatorial_polygon(amap, d1, 3) ||
+       !is_face_combinatorial_polygon(amap, d2, 3) ||
+       !is_face_combinatorial_polygon(amap, d3, 3) ||
+       !is_face_combinatorial_polygon(amap, d4, 3) ) return false;
+
+  // TODO do better with marks (?).
+  if ( belong_to_same_cell<Map,2,1>(amap, d1, d2) ||
+       belong_to_same_cell<Map,2,1>(amap, d1, d3) ||
+       belong_to_same_cell<Map,2,1>(amap, d1, d4) ||
+       belong_to_same_cell<Map,2,1>(amap, d2, d3) ||
+       belong_to_same_cell<Map,2,1>(amap, d2, d4) ||
+       belong_to_same_cell<Map,2,1>(amap, d3, d4) ) return false;
+
+  if ( amap.alpha(d1,1,2)!=amap.alpha(d3,1) ||
+       amap.alpha(d4,0,1,2)!=amap.alpha(d3,0,1) ||
+       amap.alpha(d4,1,2)!=amap.alpha(d1,0,1) ) return false;
+
+  return true;
+}
+
+
+  /** Create a new combinatorial tetrahedron.
+   * @param amap the used generalized map.
+   * @return a new dart.
+   */
+  template < class Map >
+  typename Map::Dart_handle make_combinatorial_tetrahedron(Map& amap)
+  {
+    typename Map::Dart_handle d1 = make_combinatorial_polygon(amap,3);
+    typename Map::Dart_handle d2 = make_combinatorial_polygon(amap,3);
+    typename Map::Dart_handle d3 = make_combinatorial_polygon(amap,3);
+    typename Map::Dart_handle d4 = make_combinatorial_polygon(amap,3);
+
+    return make_combinatorial_tetrahedron(amap, d1, d2, d3, d4);
+  }
+
+  /** Create a combinatorial hexahedron from 6 quadrilaterals.
+   * @param amap the used generalized map.
+   * @param d1 a dart onto a first quadrilateral.
+   * @param d2 a dart onto a second quadrilateral.
+   * @param d3 a dart onto a third quadrilateral.
+   * @param d4 a dart onto a fourth quadrilateral.
+   * @param d5 a dart onto a fifth quadrilateral.
+   * @param d6 a dart onto a sixth quadrilateral.
+   * @return a dart of the new cuboidal_cell.
+   */
+  template < class Map >
+  typename Map::Dart_handle
+  make_combinatorial_hexahedron(Map& amap,
+                                typename Map::Dart_handle d1,
+                                typename Map::Dart_handle d2,
+                                typename Map::Dart_handle d3,
+                                typename Map::Dart_handle d4,
+                                typename Map::Dart_handle d5,
+                                typename Map::Dart_handle d6)
+  {
+    amap.template topo_sew<2>(d1,
+                              amap.alpha(d4,1,0,1,0));
+    amap.template topo_sew<2>(amap.alpha(d1,0,1),
+                              amap.alpha(d6,1));
+    amap.template topo_sew<2>(amap.alpha(d1,1,0,1),
+                              d2);
+    amap.template topo_sew<2>(amap.alpha(d1,1),
+                              d5);
+
+    amap.template topo_sew<2>(d3,
+                              amap.alpha(d2,1,0,1));
+    amap.template topo_sew<2>(amap.alpha(d3,0,1,0),
+                              amap.alpha(d6,0,1));
+    amap.template topo_sew<2>(amap.alpha(d3,1,0,1,0),
+                              d4);
+    amap.template topo_sew<2>(amap.alpha(d3,1),
+                              amap.alpha(d5,0,1,0,1));
+
+    amap.template topo_sew<2>(d6,
+                              amap.alpha(d4,1,0));
+    amap.template topo_sew<2>(amap.alpha(d6,1,0,1),
+                              amap.alpha(d2,0,1));
+
+    amap.template topo_sew<2>(amap.alpha(d5,1,0),
+                              amap.alpha(d4,0,1));
+    amap.template topo_sew<2>(amap.alpha(d5,0,1),
+                              amap.alpha(d2,1));
+    return d1;
+  }
+
+/** Test if a volume is a combinatorial hexahedron.
+ * @param amap the used generalized map.
+ * @param adart an intial dart
+ * @return true iff the volume containing adart is a combinatorial hexahedron.
+ */
+template < class Map >
+bool is_volume_combinatorial_hexahedron(const Map& amap,
+                                        typename Map::Dart_const_handle d1)
+{
+  typename Map::Dart_const_handle d2 = amap.alpha(d1,1,0,1,2);
+  typename Map::Dart_const_handle d3 = amap.alpha(d2,1,0,1,2);
+  typename Map::Dart_const_handle d4 = amap.alpha(d3,1,0,1,0,2);
+  typename Map::Dart_const_handle d5 = amap.alpha(d1,1,2);
+  typename Map::Dart_const_handle d6 = amap.alpha(d4,1,0,2);
+
+  if (!is_face_combinatorial_polygon(amap, d1, 4) ||
+      !is_face_combinatorial_polygon(amap, d2, 4) ||
+      !is_face_combinatorial_polygon(amap, d3, 4) ||
+      !is_face_combinatorial_polygon(amap, d4, 4) ||
+      !is_face_combinatorial_polygon(amap, d5, 4) ||
+      !is_face_combinatorial_polygon(amap, d6, 4) ) return false;
+
+  // TODO do better with marks.
+  if ( belong_to_same_cell<Map,2,1>(amap, d1, d2) ||
+       belong_to_same_cell<Map,2,1>(amap, d1, d3) ||
+       belong_to_same_cell<Map,2,1>(amap, d1, d4) ||
+       belong_to_same_cell<Map,2,1>(amap, d1, d5) ||
+       belong_to_same_cell<Map,2,1>(amap, d1, d6) ||
+       belong_to_same_cell<Map,2,1>(amap, d2, d3) ||
+       belong_to_same_cell<Map,2,1>(amap, d2, d4) ||
+       belong_to_same_cell<Map,2,1>(amap, d2, d5) ||
+       belong_to_same_cell<Map,2,1>(amap, d2, d6) ||
+       belong_to_same_cell<Map,2,1>(amap, d3, d4) ||
+       belong_to_same_cell<Map,2,1>(amap, d3, d5) ||
+       belong_to_same_cell<Map,2,1>(amap, d3, d6) ||
+       belong_to_same_cell<Map,2,1>(amap, d4, d5) ||
+       belong_to_same_cell<Map,2,1>(amap, d4, d6) ||
+       belong_to_same_cell<Map,2,1>(amap, d5, d6) )
+    return false;
+
+  if ( amap.alpha(d1,2)      !=amap.alpha(d4,0,1,0,1) ||
+       amap.alpha(d1,0,1,2)  !=amap.alpha(d6,1)       ||
+       amap.alpha(d3,0,1,2)  !=amap.alpha(d6,0,1,0)   ||
+       amap.alpha(d3,1,2)    !=amap.alpha(d5,0,1,0,1) ||
+       amap.alpha(d6,1,0,1,2)!=amap.alpha(d2,0,1)     ||
+       amap.alpha(d5,1,2)    !=amap.alpha(d4,0,1,0)   ||
+       amap.alpha(d5,0,1,2)  !=amap.alpha(d2,1) ) return false;
+
+  return true;
+}
+
+  /** Create a new combinatorial hexahedron.
+   * @param amap the used generalized map.
+   * @return a new dart.
+   */
+  template < class Map >
+  typename Map::Dart_handle make_combinatorial_hexahedron(Map& amap)
+  {
+    typename Map::Dart_handle d1 = make_combinatorial_polygon(amap,4);
+    typename Map::Dart_handle d2 = make_combinatorial_polygon(amap,4);
+    typename Map::Dart_handle d3 = make_combinatorial_polygon(amap,4);
+    typename Map::Dart_handle d4 = make_combinatorial_polygon(amap,4);
+    typename Map::Dart_handle d5 = make_combinatorial_polygon(amap,4);
+    typename Map::Dart_handle d6 = make_combinatorial_polygon(amap,4);
+
+    return make_combinatorial_hexahedron(amap, d1, d2, d3, d4, d5, d6);
+  }
+
+} // namespace CGAL
+
+#endif // CGAL_GENERALIZED_MAP_CONSTRUCTORS_H //
+// EOF //

Generalized_map/include/CGAL/Generalized_map_insertions.h

@@ -0,0 +1,545 @@
+// Copyright (c) 2014 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_GENERALIZED_MAP_INSERTIONS_H
+#define CGAL_GENERALIZED_MAP_INSERTIONS_H
+
+namespace CGAL
+{
+/** @file Generalized_map_insertions.h
+ * Insertion operations on generalized map.
+ */
+
+/** Insert a vertex in a given edge.
+ * @param amap the used generalized map.
+ * @param adart a dart of the edge (!=NULL).
+ * @return a dart of the new vertex.
+ */
+template<class CMap>
+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 )
+{
+  typename CMap::Dart_handle d1, d2;
+  int mark=amap.get_new_mark();
+
+  // 1) We store all the darts of the edge.
+  std::deque<typename CMap::Dart_handle> vect;
+  int 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<typename CMap::Dart_handle>::iterator it = vect.begin();
+  for (; it != vect.end(); ++it)
+  {
+    d1 = amap.create_dart();
+
+    if (!amap.template is_free<0>(*it) &&
+        amap.is_marked(amap.template alpha<0>(*it), mark))
+      amap.template basic_link_alpha<1>(d1, amap.template alpha<0,0>(*it));
+
+    amap.template basic_link_alpha<0>(*it, d1);
+    amap.mark(*it, mark);
+
+    for ( unsigned int dim=2; dim<=CMap::dimension; ++dim )
+    {
+      if (!amap.is_free(*it, dim) && amap.is_marked(amap.alpha(*it, dim), mark))
+      {
+        amap.basic_link_alpha(amap.beta(*it, dim, 0), d1, dim);
+      }
+    }
+
+    // We copy all the attributes except for dim=0
+    CMap::Helper::template Foreach_enabled_attributes_except
+      <CGAL::internal::Group_attribute_functor_of_dart<CMap>, 0>::
+      run(&amap,*it,d1);
+    // We initialise the 0-atttrib to ah
+    CGAL::internal::Set_i_attribute_of_dart_functor<CMap, 0>::
+        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.template is_free<1>(amap.template alpha<0>(adart)) )
+  {
+    CGAL::internal::Degroup_attribute_functor_run<CMap, 1>::
+      run(&amap, adart, amap.template alpha<0,1>(adart));
+  }
+
+#ifdef CGAL_CMAP_TEST_VALID_INSERTIONS
+  CGAL_assertion( amap.is_valid() );
+#endif
+
+  return amap.template alpha<0>(adart);
+}
+
+/** Insert a vertex in the given 2-cell which is splitted in triangles,
+ * once for each inital edge of the facet.
+ * @param amap the used generalized map.
+ * @param adart a dart of the facet to triangulate.
+ * @return A dart incident to the new vertex.
+ */
+template < class CMap >
+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 )
+{
+  CGAL_assertion(adart!=amap.null_handle);
+
+  typename CMap::Dart_handle d1=amap.null_handle, d2=amap.null_handle;
+
+  // Mark used to mark darts already treated.
+  int treated = amap.get_new_mark();
+  int m = amap.get_new_mark();
+
+  // Stack of darts of the face
+  std::deque<typename CMap::Dart_handle> vect;
+  {
+    for ( typename CMap::template Dart_of_cell_basic_range<2>::iterator
+            it=amap.template darts_of_cell_basic<2>(adart,m).begin();
+          it != amap.template darts_of_cell_basic<2>(adart,m).end(); ++it )
+      vect.push_back(it);
+  }
+
+  // Stack of darts to degroup (one dart per edge of the face)
+  std::deque<typename CMap::Dart_handle> todegroup;
+  {
+    for ( typename CMap::template Dart_of_cell_basic_range<2,2>::iterator
+            it=amap.template darts_of_cell_basic<2,2>(adart).begin();
+          it != amap.template darts_of_cell_basic<2,2>(adart).end(); ++it )
+      if ( it!=adart && it!=amap.template alpha<0>(adart) )
+        todegroup.push_back(it);
+  }
+
+  // 2) For each dart of the cell, we modify link of neighbors.
+  typename std::deque<typename CMap::Dart_handle>::iterator it = vect.begin();
+  for (; it != vect.end(); ++it)
+  {
+    d1 = amap.create_dart();
+    d2 = amap.create_dart();
+    amap.template basic_link_alpha<0>(d1, d2);
+    amap.mark(*it, treated);
+
+    amap.template basic_link_alpha<1>(*it, d1);
+
+    if (!amap.template is_free<0>(*it) &&
+        amap.is_marked(amap.template alpha<0>(*it), treated))
+      amap.template basic_link_alpha<1>(d2, amap.template alpha<0,1,0>(*it));
+
+    for ( unsigned int dim=3; dim<=CMap::dimension; ++dim )
+    {
+      if (!amap.is_free(*it, dim) && amap.is_marked(amap.alpha(*it, dim), treated))
+      {
+        amap.basic_link_alpha(amap.beta(*it, dim, 1), d1, dim);
+        amap.basic_link_alpha(amap.beta(*it, dim, 1, 0), d2, dim);
+      }
+    }
+
+    // We copy all the attributes except for dim=1
+    CMap::Helper::template Foreach_enabled_attributes_except
+      <CGAL::internal::Group_attribute_functor_of_dart<CMap>, 1>::
+      run(&amap,*it,d1);
+    // We initialise the 0-atttrib to ah
+    CGAL::internal::Set_i_attribute_of_dart_functor<CMap, 0>::
+        run(&amap, d2, ah);
+  }
+
+  for (it = vect.begin(); it != vect.end(); ++it)
+  {
+    amap.unmark(*it, m);
+    amap.unmark(*it, treated);
+  }
+
+  CGAL_assertion(amap.is_whole_map_unmarked(m));
+  CGAL_assertion(amap.is_whole_map_unmarked(treated));
+  amap.free_mark(m);
+  amap.free_mark(treated);
+
+  for (it = todegroup.begin(); it != todegroup.end(); ++it)
+  {
+    CGAL::internal::Degroup_attribute_functor_run<CMap, 2>::
+      run(&amap, adart, *it);
+  }
+
+#ifdef CGAL_CMAP_TEST_VALID_INSERTIONS
+  CGAL_assertion( amap.is_valid() );
+#endif
+
+  return amap.template alpha<1,0>(adart);
+}
+
+/** Test if an edge can be inserted onto a 2-cell between two given darts.
+ * @param amap the used generalized map.
+ * @param adart1 a first dart.
+ * @param adart2 a second dart.
+ * @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)
+{
+  if ( adart1==adart2 || adart1==amap.template alpha<0>(adart2) ) return false;
+  for ( CGAL::CMap_dart_const_iterator_of_orbit<CMap,0,1> it(amap,adart1);
+        it.cont(); ++it )
+  {
+    if ( it==adart2 )  return true;
+  }
+  return false;
+}
+
+/** Insert an edge in a 2-cell between two given darts.
+ * @param amap the used generalized map.
+ * @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.
+ * @return a dart of the new edge, and not incident to the
+ *         same vertex than adart1.
+ */
+template<class CMap>
+typename CMap::Dart_handle
+insert_cell_1_in_cell_2(CMap& amap,
+                        typename CMap::Dart_handle adart1,
+                        typename CMap::Dart_handle adart2)
+{
+  if ( adart2!=amap.null_handle)
+  {
+    CGAL_assertion(is_insertable_cell_1_in_cell_2<CMap>(amap, adart1, adart2));
+  }
+
+  int m1=amap.get_new_mark();
+  CGAL::CMap_dart_iterator_basic_of_involution<CMap,1> it1(amap, adart1, m1);
+
+  int m2=amap.get_new_mark();
+  CGAL::CMap_dart_iterator_basic_of_involution<CMap,1> it2(amap, adart2, m2);
+
+  typename CMap::Dart_handle d1=amap.null_handle;
+  typename CMap::Dart_handle d2=amap.null_handle;
+
+  int treated=amap.get_new_mark();
+
+  for ( ; it1.cont(); ++it1)
+  {
+    CGAL_assertion (it2.cont() );
+    d1 = amap.create_dart();
+    d2 = amap.create_dart();
+    amap.template basic_link_alpha<0>(d1, d2);
+    amap.mark(it1,treated);
+
+    if ( !amap.template is_free<1>(it1) &&
+         amap.is_marked(amap.template alpha<1>(it1), treated) )
+    {
+      amap.template basic_link_alpha<2>(amap.template alpha<1,1>(it1), d1);
+      amap.template basic_link_alpha<2>(amap.template alpha<2,0>(d1), d2);
+    }
+
+    for ( unsigned int dim=3; dim<=CMap::dimension; ++dim)
+    {
+      if ( !amap.is_free(it1, dim) &&
+           amap.is_marked(amap.alpha(it1, dim), treated) )
+      {
+        amap.basic_link_alpha(amap.alpha(it1, dim, 1), d1, dim);
+        amap.basic_link_alpha(amap.alpha(d1, dim, 0), d2, dim);
+      }
+    }
+
+    amap.template link_alpha<1>(it1, d1);
+    if ( adart2!=amap.null_handle )
+    {
+      amap.template link_alpha<1>(it2, d2);
+      ++it2;
+    }
+  }
+
+  if ( !amap.template is_free<2>(d1) && d2!=amap.null_handle )
+    CGAL::internal::Degroup_attribute_functor_run<CMap, 2>::
+      run(&amap, d1, amap.template alpha<2>(d1));
+
+  amap.negate_mark(m1);
+  it1.rewind();
+
+  if ( adart2!=amap.null_handle )
+  { it2.rewind(); amap.negate_mark(m2); }
+
+  for ( ; it1.cont(); ++it1, ++it2)
+  {
+    amap.mark(it1,m1);
+    amap.unmark(it1,treated);
+    if ( adart2!=amap.null_handle ) amap.mark(it2,m2);
+  }
+  amap.negate_mark(m1);
+  CGAL_assertion( amap.is_whole_map_unmarked(m1) );
+  CGAL_assertion( amap.is_whole_map_unmarked(treated) );
+  amap.free_mark(m1);
+  amap.free_mark(treated);
+
+  if ( adart2!=amap.null_handle )
+  {
+    amap.negate_mark(m2);
+    CGAL_assertion( amap.is_whole_map_unmarked(m2) );
+  }
+  amap.free_mark(m2);
+
+#ifdef CGAL_CMAP_TEST_VALID_INSERTIONS
+  CGAL_assertion( amap.is_valid() );
+#endif
+
+  return amap.template alpha<1>(adart1);
+}
+
+/** Test if a 2-cell can be inserted onto a given 3-cell along
+ * a path of edges.
+ * @param amap the used generalized map.
+ * @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.
+ * the path is a sequence of dartd, one per edge
+ * where the face will be inserted.
+ */
+template <class CMap, class InputIterator>
+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) 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)
+    {
+      if ( amap.template is_free<0>(prec) ) return false;
+
+      // alpha0(prec) and *it must belong to the same vertex of the same volume
+      if ( !CGAL::belong_to_same_cell<CMap, 0, 2>
+           (amap,  amap.template alpha<0>(prec), *it) )
+        return false;
+    }
+    prec = *it;
+  }
+
+  // The path must be closed.
+  if ( amap.template is_free<0>(prec) ) return false;
+  if (!CGAL::belong_to_same_cell<CMap, 0, 2>
+      (amap, amap.template alpha<0>(prec), *afirst))
+    return false;
+
+  return true;
+}
+
+/** Insert a 2-cell in a given 3-cell along a path of darts.
+ * @param amap the used generalized map.
+ * @param afirst iterator on the begining of the path.
+ * @param alast  iterator on the end of the path.
+ * the path is a sequence of dartd, one per edge
+ * where the face will be inserted.
+ * @return a dart of the new 2-cell.
+ */
+template<class CMap, class InputIterator>
+typename CMap::Dart_handle
+insert_cell_2_in_cell_3(CMap& amap, InputIterator afirst, InputIterator alast)
+{
+  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 withAlpha3 = false;
+
+  int treated = amap.get_new_mark();
+
+  {
+    for (InputIterator it(afirst); !withAlpha3 && it!=alast; ++it)
+    {
+      if (!amap.template is_free<2>(*it)) withAlpha3 = true;
+    }
+  }
+
+  {
+    for (InputIterator it(afirst); it!=alast; ++it)
+    {
+      d = amap.create_dart();
+      amap.template basic_link_alpha<0>(d, amap.create_dart());
+
+      if ( withAlpha3 )
+      {
+        dd = amap.create_dart();
+        amap.template basic_link_alpha<0>(dd, amap.create_dart());
+      }
+
+      if ( prec!=amap.null_handle )
+      {
+        amap.template basic_link_alpha<1>(prec, d);
+        if (withAlpha3)
+          amap.template basic_link_alpha<1>(amap.template alpha<3>(prec), dd);
+      }
+      else first = amap.template alpha<0>(d);
+
+      if ( !amap.template is_free<2>(*it) )
+      {
+        amap.template link_alpha<2>(amap.template alpha<2>(*it), dd);
+      }
+
+      amap.template link_alpha<2>(*it, d);
+      if (withAlpha3) amap.template basic_link_alpha<3>(d, dd);
+
+      prec = amap.template alpha<0>(d);
+    }
+  }
+
+  amap.template basic_link_alpha<1>(prec, first);
+  if ( withAlpha3 )
+  {
+    amap.template basic_link_alpha<1>(amap.template alpha<3>(prec),
+                                      amap.template alpha<3>(first));
+  }
+
+  // Make copies of the new facet for dimension >=4
+  /*  for ( unsigned int dim=4; dim<=CMap::dimension; ++dim )
+  {
+    if ( !amap.is_free(*it, dim) )
+    {
+          ddd = amap.create_dart();
+          amap.template basic_link_alpha<0>(ddd, amap.create_dart());
+          amap.basic_link_alpha(d, ddd, dim);
+          amap.basic_link_alpha(amap.template alpha<0>(d),
+                                amap.template alpha<0>(ddd), dim);
+
+          if ( withAlpha3 )
+          {
+            dddd = amap.create_dart();
+            amap.template basic_link_alpha<0>(dddd, amap.create_dart());
+
+            amap.basic_link_alpha(dd, dddd, dim);
+            amap.basic_link_alpha(amap.template alpha<0>(dd),
+                                  amap.template alpha<0>(dddd), dim);
+          }
+
+
+
+        }
+        }*/
+
+  // 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<CMap,0,1> it(amap, first);
+            it.cont(); ++it )
+      {
+        d = amap.create_dart();
+        amap.basic_link_alpha(amap.template alpha<2>(it), d, dim);
+        if ( withAlpha3 )
+        {
+          dd = amap.create_dart();
+          amap.basic_link_alpha_for_involution
+            (amap.template alpha<2,3>(it), dd, dim);
+          amap.template basic_link_alpha_for_involution<3>(d, dd);
+        }
+        if ( prec!=amap.null_handle )
+        {
+          amap.link_alpha_0(prec, d);
+          if ( withAlpha3 )
+          {
+            amap.basic_link_alpha_1(amap.template alpha<3>(prec), dd);
+          }
+        }
+        else first2 = prec;
+
+        // We consider dim2=2 out of the loop to use link_alpha instead of
+        // basic _link_alpha (to modify non void attributes only once).
+        if ( !amap.template is_free<2>(it) &&
+             amap.is_free(amap.template alpha<2>(it), dim) )
+          amap.template link_alpha_for_involution<2>
+            (amap.alpha(it,2,dim), d);
+        if ( withAlpha3 &&
+             !amap.template is_free<2>(amap.template alpha<3>(it)) &&
+             amap.is_free(amap.template alpha<3,2>(it), dim) )
+          amap.template link_alpha_for_involution<2>(amap.alpha(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.alpha(it, dim2), dim) )
+              amap.basic_link_alpha_for_involution(amap.alpha(it, dim2, dim),
+                                                  d, dim2);
+            if ( withAlpha3 && !amap.is_free(amap.template alpha<3>(it), dim2) &&
+                 amap.is_free(amap.alpha(it, 3, dim2), dim) )
+              amap.basic_link_alpha_for_involution
+                (amap.alpha(it, 3, dim2, dim), dd, dim2);
+          }
+        }
+        prec = d;
+      }
+      amap.basic_link_alpha_0( prec, first2 );
+      if ( withAlpha3 )
+      {
+        amap.basic_link_alpha_1( amap.template alpha<3>(prec),
+                                amap.template alpha<3>(first2) );
+      }
+    }
+  }
+
+  // Degroup the attributes
+  if ( withAlpha3 )
+  { // Here we cannot use Degroup_attribute_functor_run as new darts do not
+    // have their 3-attribute
+    CGAL::internal::Degroup_attribute_functor_run<CMap, 3>::
+        run(&amap, first, amap.template alpha<3>(first));
+  }
+
+#ifdef CGAL_CMAP_TEST_VALID_INSERTIONS
+  CGAL_assertion( amap.is_valid() );
+#endif
+
+  return first;
+}
+
+} // namespace CGAL
+
+#endif // CGAL_GENERALIZED_MAP_INSERTIONS_H

Generalized_map/include/CGAL/Generalized_map_iterators_base.h

@@ -0,0 +1,237 @@
+// Copyright (c) 2014 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_GENERALIZED_MAP_ITERATORS_BASE_HH
+#define CGAL_GENERALIZED_MAP_ITERATORS_BASE_HH 1
+
+ // to get OperationState type, some OP, and CMap_dart_iterator
+#include <CGAL/Combinatorial_map_iterators_base.h>
+
+// Other includes
+#include <CGAL/Compact_container.h>
+#include <queue>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace CGAL {
+
+  /** @file generalized_map_iterators_base.h
+   * Basic classes that serve as tools for definition of iterators.
+   * There is 1 class:
+   *  - GMap_extend_iterator<GMap,Ite,Ai> to extend the given iterator by
+   *    adding the involution Ai.
+   */
+    //****************************************************************************
+  /// Enum of all the possible operations used by the ++ operator.
+  /// Extension of the enum for generalized maps.
+  enum
+    {
+    OP_ALPHAI=OP_END+1, ///< Previous op was the first alpha.
+    OP_ALPHAJ,     ///< Previous op was the second alpha.
+    OP_ALPHAK,     ///< Previous op was the third alpha.
+    OP_ALPHAIJ,    ///< Previous op was the composition of two alpha.
+    OP_ALPHAJI,    ///< Previous op was the composition of two alpha.
+    };
+  //****************************************************************************
+  /* Class GMap_extend_iterator<Map,Ite,Ai> which extend a given iterator by
+   * adding Ai and by using a stack and a mark.
+   * General case when Ite does not have already a stack.
+   */
+  template <typename Map_,typename Ite,int Ai,
+            typename Ite_has_stack=typename Ite::Use_mark>
+  class GMap_extend_iterator: public Ite
+  {
+  public:
+    typedef GMap_extend_iterator<Map_,Ite,Ai, Ite_has_stack> Self;
+    typedef Ite Base;
+
+    typedef typename Base::Dart_handle Dart_handle;
+    typedef typename Base::Map Map;
+
+    typedef Tag_true Use_mark;
+
+    CGAL_static_assertion( (Ai<=Map::dimension &&
+                            boost::is_same<Ite_has_stack,Tag_false>::value) );
+
+  public:
+    /// Main constructor.
+    GMap_extend_iterator(Map& amap, Dart_handle adart, int amark):
+      Base(amap, adart),
+      mmark_number(amark),
+      minitial_dart(adart)
+    {
+      if ( adart!=amap.null_handle )
+      {
+        this->mmap->mark(adart, mmark_number);
+        if (!this->mmap->template is_free<Ai>(adart))
+        {
+          mto_treat.push(this->mmap->template alpha<Ai>(adart));
+          this->mmap->mark(this->mmap->template alpha<Ai>(adart),
+                           mmark_number);
+        }
+      }
+    }
+
+    /// Rewind of the iterator to its beginning.
+    void rewind()
+    {
+      CGAL_assertion(mmark_number != -1);
+      Base::operator= ( Base(*this->mmap,minitial_dart) );
+      mto_treat = std::queue<Dart_handle>();
+      this->mmap->mark(minitial_dart, mmark_number);
+      if (!this->mmap->template is_free<Ai>(minitial_dart))
+      {
+        mto_treat.push(this->mmap->template alpha<Ai>(minitial_dart));
+        this->mmap->mark(this->mmap->template alpha<Ai>(minitial_dart),
+                         mmark_number);
+      }
+    }
+
+    /// Prefix ++ operator.
+    Self& operator++()
+    {
+      CGAL_assertion(mmark_number != -1);
+      CGAL_assertion(this->cont());
+
+      do
+      {
+        Base::operator++();
+      }
+      while ( this->cont() &&
+              this->mmap->is_marked(*this, mmark_number) );
+
+      if ( !this->cont() )
+      {
+        if ( !mto_treat.empty() )
+        {
+          Base::operator= ( Base(*this->mmap,mto_treat.front()) );
+          mto_treat.pop();
+          this->mprev_op = OP_POP;
+          CGAL_assertion( this->mmap->is_marked((*this), mmark_number) );
+
+          if (!this->mmap->is_free(*this, Ai) &&
+              !this->mmap->is_marked(this->mmap->alpha(*this, Ai), mmark_number) )
+          {
+            mto_treat.push(this->mmap->alpha(*this, Ai));
+            this->mmap->mark(this->mmap->alpha(*this, Ai), mmark_number);
+          }
+        }
+      }
+      else
+      {
+        this->mmap->mark((*this), mmark_number);
+        if (!this->mmap->is_free(*this, Ai) &&
+            !this->mmap->is_marked(this->mmap->alpha(*this, Ai), mmark_number) )
+        {
+          mto_treat.push(this->mmap->alpha(*this, Ai));
+          this->mmap->mark(this->mmap->alpha(*this, Ai), mmark_number);
+        }
+      }
+
+      return *this;
+    }
+
+    /// Postfix ++ operator.
+    Self operator++(int)
+    { Self res=*this; operator ++(); return res; }
+
+  protected:
+    /// Queue of darts to process.
+    std::queue<Dart_handle> mto_treat;
+
+    /// Index of the used mark.
+    int mmark_number;
+
+    /// Initial dart
+    Dart_handle minitial_dart;
+  };
+  //****************************************************************************
+  /* Class GMap_extend_iterator<Map,Ite,Ai> which extend a given iterator by
+   * adding Ai and by using a stack and a mark.
+   * Specialization when Ite has already a stack.
+   */
+  template <typename Map_,typename Ite,int Ai>
+  class GMap_extend_iterator<Map_,Ite,Ai,Tag_true>: public Ite
+  {
+  public:
+    typedef GMap_extend_iterator<Map_,Ite,Ai,Tag_true> Self;
+    typedef Ite Base;
+
+    typedef typename Base::Dart_handle Dart_handle;
+    typedef typename Base::Map Map;
+
+    typedef Tag_true Use_mark;
+
+    /// Main constructor.
+    GMap_extend_iterator(Map& amap, Dart_handle adart, int amark):
+      Base(amap, adart, amark)
+    {
+      if (adart!=amap.null_handle)
+      {
+        if (!this->mmap->is_free(adart, Ai) &&
+            !this->mmap->is_marked(this->mmap->alpha(amap, Ai), this->mmark_number))
+        {
+          this->mto_treat.push(adart->alpha(Ai));
+          this->mmap->mark(this->mmap->alpha(this->minitial_dart, Ai), this->mmark_number);
+        }
+      }
+    }
+
+    /// Rewind of the iterator to its beginning.
+    void rewind()
+    {
+      CGAL_assertion(this->mmark_number != -1);
+      Base::rewind();
+      if ( !this->mmap->is_free(this->minitial_dart, Ai) )
+      {
+        this->mto_treat.push(this->mmap->alpha(this->minitial_dart, Ai));
+        this->mmap->mark(this->mmap->alpha(this->minitial_dart, Ai), this->mmark_number);
+      }
+    }
+
+    /// Prefix ++ operator.
+    Self& operator++()
+    {
+      Base::operator++();
+
+      if ( this->cont() )
+      {
+        CGAL_assertion( this->mmap->is_marked(*this, this->mmark_number) );
+
+        if (!this->mmap->is_free(*this, Ai) &&
+            !this->mmap->is_marked(this->mmap->alpha(*this, Ai),
+                                   this->mmark_number))
+        {
+          this->mto_treat.push(this->mmap->alpha(*this, Ai));
+          this->mmap->mark(this->mmap->alpha(*this, Ai), this->mmark_number);
+        }
+      }
+      return *this;
+    }
+
+    /// Postfix ++ operator.
+    Self operator++(int)
+    { Self res=*this; operator ++(); return res; }
+  };
+  //****************************************************************************
+  //****************************************************************************
+} // namespace CGAL
+//******************************************************************************
+#endif // CGAL_GENERALIZED_MAP_ITERATORS_BASE_HH
+//******************************************************************************

Generalized_map/include/CGAL/Generalized_map_min_items.h

@@ -0,0 +1,50 @@
+// Copyright (c) 2014 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_GENERALIZED_MAP_MIN_ITEMS_H
+#define CGAL_GENERALIZED_MAP_MIN_ITEMS_H 1
+
+#include <CGAL/GMap_dart.h>
+
+namespace CGAL {
+
+/** @file Generalized_map_min_items.h
+ * Definition of min item class for dD generalized map.
+ */
+
+/** Minimal items for dD generalized map.
+ * Generalized_map_min_items defines what is the minimal item
+ * class for a d-gmap It provides definitions for darts without attribute.
+ */
+template <unsigned int d>
+struct Generalized_map_min_items
+{
+   /// Dart_wrapper defines the type of darts used, and enabled attributes.
+   template < class Refs >
+   struct Dart_wrapper
+   {
+     typedef CGAL::GMap_dart< d, Refs > Dart;
+     typedef CGAL::cpp11::tuple<> Attributes;
+   };
+};
+
+} // namespace CGAL
+
+#endif // CGAL_GENERALIZED_MAP_MIN_ITEMS_H //
+// EOF //

Generalized_map/include/CGAL/Generalized_map_operations.h

@@ -0,0 +1,422 @@
+// Copyright (c) 2014 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_GENERALIZED_MAP_OPERATIONS_H
+#define CGAL_GENERALIZED_MAP_OPERATIONS_H 1
+
+#include <CGAL/Generalized_map.h>
+#include <CGAL/Generalized_map_insertions.h>
+#include <deque>
+#include <stack>
+
+namespace CGAL
+{
+  /** @file Generalized_map_operations.h
+   * Some operations to modify a generalized map.
+   */
+
+  /** Test if an i-cell can be removed.
+   *  An i-cell can be removed if i==CMap::dimension or i==CMap::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 <class CMap, unsigned int i, unsigned int nmi=CMap::dimension-i>
+  struct Is_removable_functor
+  {
+    static bool run(const CMap& amap, typename CMap::Dart_const_handle adart)
+    {
+      // TODO? Optimisation for dim-2, and to not test all the darts of the cell?
+      bool res = true;
+      for ( CGAL::GMap_dart_const_iterator_of_cell<CMap,i> it(amap, adart);
+            res && it.cont(); ++it )
+      {
+        if (amap.template alpha<i+2,i+1>(it)!=amap.template alpha<i+1,i+2>(it))
+          res = false;
+      }
+      return res;
+    }
+  };
+  // Specialization for i=CMap::dimension
+  template <class CMap, unsigned int i>
+  struct Is_removable_functor<CMap, i, 0>
+  {
+    static bool run(const CMap&, typename CMap::Dart_const_handle)
+    { return true; }
+  };
+  // Specialization for i=CMap::dimension-1
+  template <class CMap, unsigned int i>
+  struct Is_removable_functor<CMap, i, 1>
+  {
+    static bool run(const CMap&, typename CMap::Dart_const_handle)
+    { return true; }
+  };
+  /** Test if an i-cell can be removed.
+   *  An i-cell can be removed if i==CMap::dimension or i==CMap::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 < class CMap, unsigned int i >
+  bool is_removable(const CMap& amap, typename CMap::Dart_const_handle adart)
+  { return CGAL::Is_removable_functor<CMap, i>::run(amap,adart); }
+
+  /** Remove an i-cell, 0<=i<dimension, and merge eventually both incident
+   *  (i+1)-cells.
+   *  @param amap the used generalized map.
+   *  @param adart a dart of the i-cell to remove.
+   *  @return the number of deleted darts.
+   */
+  template<class CMap, unsigned int i, unsigned int nmi>
+  struct Remove_cell_functor
+  {
+    static size_t run(CMap& amap, typename CMap::Dart_handle adart)
+    {
+      CGAL_static_assertion ( i<CMap::dimension );
+      CGAL_assertion( (is_removable<CMap,i>(amap, adart)) );
+
+      size_t res = 0;
+
+      typename CMap::Dart_handle d1, d2;
+      typename CMap::Dart_handle dg1=amap.null_handle, dg2=amap.null_handle;
+
+      int mark = amap.get_new_mark();
+      int mark_modified_darts = amap.get_new_mark();
+
+      std::deque<typename CMap::Dart_handle> to_erase;
+
+      // First we store and mark all the darts of the i-cell to remove.
+      for ( CGAL::GMap_dart_iterator_basic_of_cell<CMap,i> it(amap,adart,mark);
+            it.cont(); ++it )
+      {
+        to_erase.push_back(it);
+        if ( !amap.template is_free<i+1>(it) && dg1==amap.null_handle )
+        { dg1=it; dg2=amap.template alpha<i+1>(it); }
+        amap.mark(it, mark);
+        ++res;
+      }
+
+      // We group the two (i+1)-cells incident if they exist.
+      if ( dg1!=amap.null_handle )
+        CGAL::internal::Group_attribute_functor_run<CMap, i+1>::
+            run(&amap, dg1, dg2);
+
+      // During the operation, we store in modified_darts the darts modified
+      // to test after the loop the non void attributes that are split.
+      std::deque<typename CMap::Dart_handle> modified_darts;
+
+      // For each dart of the i-cell, we modify i-links of neighbors.
+      typename std::deque<typename CMap::Dart_handle>::iterator it =
+          to_erase.begin();
+      for ( ; it!=to_erase.end(); ++it )
+      {
+        d1=amap.template alpha<i>(*it);
+
+        if ( !amap.is_marked(d1, mark) )
+        {
+          d2=amap.template alpha<i+1,i>(*it);
+          while ( amap.is_marked(d2, mark) )
+          {
+            d2=amap.template alpha<i+1,i>(d2);
+          }
+
+          if ( !amap.is_marked(d1, mark_modified_darts) )
+          {
+            CGAL_assertion( !amap.is_marked(d2, mark_modified_darts) );
+            amap.template basic_link_alpha<i>(d1, d2);
+            amap.mark(d1, mark_modified_darts);
+            modified_darts.push_back(d1);
+            // TODO push only one out of two dart ?
+            if ( d2!=d1 )
+            {
+              modified_darts.push_back(d2);
+              amap.mark(d2, mark_modified_darts);
+            }
+          }
+        }
+      }
+
+      // We test the split of all the incident cells for all the non
+      // void attributes.
+      CMap::Helper::template Foreach_enabled_attributes_except
+        <CGAL::internal::Test_split_attribute_functor<CMap,i>, i>::
+        run(&amap, modified_darts, mark_modified_darts);
+
+      // We remove all the darts of the i-cell.
+      for ( it=to_erase.begin(); it!=to_erase.end(); ++it )
+      { amap.erase_dart(*it); }
+
+      CGAL_assertion( amap.is_whole_map_unmarked(mark) );
+      amap.free_mark(mark);
+
+      // If no attribute is enabled (or if only i-attributes are enabled),
+      // the darts are not unmark by Foreach_enabled_attributes_except.
+      // Thus we unmark them now.
+      if ( !amap.is_whole_map_unmarked(mark_modified_darts) )
+      {
+        for ( it=modified_darts.begin();
+              it!=modified_darts.end(); ++it )
+          amap.unmark(*it, mark_modified_darts);
+      }
+
+      CGAL_assertion ( amap.is_whole_map_unmarked(mark_modified_darts) );
+      amap.free_mark(mark_modified_darts);
+
+#ifdef CGAL_GMAP_TEST_VALID_REMOVALS
+      CGAL_assertion( amap.is_valid() );
+#endif
+
+      return res;
+    }
+  };
+
+  /** Remove a d-cell, in a d-map (special case).
+   *  @param amap the used combinatorial map.
+   *  @param adart a dart of the volume to remove.
+   *  @return the number of deleted darts.
+   */
+  template<class Gmap,unsigned int i>
+  struct Remove_cell_functor<Gmap,i,0>
+  {
+    static size_t run(Gmap& amap, typename Gmap::Dart_handle adart)
+    {
+      int mark = amap.get_new_mark();
+      std::deque<typename Gmap::Dart_handle> to_erase;
+      size_t res = 0;
+
+      std::deque<typename Gmap::Dart_handle> modified_darts;
+
+      // We mark all the darts of the d-cell.
+      for ( CGAL::GMap_dart_iterator_basic_of_cell<Gmap,Gmap::dimension>
+            it(amap,adart,mark); it.cont(); ++it )
+      {
+        to_erase.push_back(it);
+        amap.mark(it,mark);
+        ++res;
+      }
+
+      // We unlink all the darts of the volume for alpha-d.
+      typename std::deque<typename Gmap::Dart_handle>::iterator
+        it = to_erase.begin();
+      for ( it = to_erase.begin(); it != to_erase.end(); ++it )
+      {
+        if ( !amap.template is_free<Gmap::dimension>(*it) &&
+             !amap.is_marked(amap.template alpha<Gmap::dimension>(*it), mark) )
+        {
+          modified_darts.push_back(amap.template alpha<Gmap::dimension>(*it));
+          amap.template unlink_alpha<Gmap::dimension>(*it);
+        }
+      }
+
+      // We test the split of all the incident cells for all the non
+      // void attributes.
+      Gmap::Helper::template Foreach_enabled_attributes_except
+          <CGAL::internal::Test_split_attribute_functor<Gmap,i>,
+          Gmap::dimension>::run(&amap, modified_darts);
+
+      // We remove all the darts of the d-cell.
+      for ( it = to_erase.begin(); it != to_erase.end(); ++it )
+      { amap.erase_dart(*it); }
+
+      CGAL_assertion( amap.is_whole_map_unmarked(mark) );
+      amap.free_mark(mark);
+
+#ifdef CGAL_GMAP_TEST_VALID_REMOVALS
+      CGAL_assertion( amap.is_valid() );
+#endif
+
+      return res;
+    }
+  };
+
+  /** Remove an i-cell, 0<=i<=dimension.
+   * @param amap the used generalized map.
+   * @param adart a dart of the i-cell to remove.
+   * @return the number of deleted darts.
+   */
+  template< class Gmap, unsigned int i >
+  size_t remove_cell(Gmap& amap, typename Gmap::Dart_handle adart)
+  {
+    return
+        CGAL::Remove_cell_functor<Gmap,i,Gmap::dimension-i>::run(amap,adart);
+  }
+
+  /** 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 <class Gmap, unsigned int i>
+  struct Is_contractible_functor
+  {
+    static bool run(const Gmap& amap, typename Gmap::Dart_const_handle adart)
+    {
+      // TODO ? Optimisation possible to not test all the darts of the cell ?
+      bool res = true;
+      for ( CGAL::GMap_dart_const_iterator_of_cell<Gmap,i> it(amap, adart);
+            res && it.cont(); ++it )
+      {
+        if (amap.template alpha<i-2,i-1>(it)!=amap.template alpha<i-1,i-2>(it))
+          res = false;
+      }
+      return res;
+    }
+  };
+  // Specialization for i=0
+  template <class Gmap>
+  struct Is_contractible_functor<Gmap, 0>
+  {
+    static bool run(const Gmap&, typename Gmap::Dart_const_handle)
+    { return false; }
+  };
+  // Specialization for i=1
+  template <class Gmap>
+  struct Is_contractible_functor<Gmap, 1>
+  {
+    static bool run(const Gmap&, typename Gmap::Dart_const_handle)
+    { return true; }
+  };
+  /** 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 < class Gmap, unsigned int i >
+  bool is_contractible(const Gmap& amap, typename Gmap::Dart_const_handle adart)
+  { return CGAL::Is_contractible_functor<Gmap, i>::run(amap,adart); }
+
+  /** Contract an i-cell, 1<=i<=dimension, and merge eventually both incident
+   *  (i-1)-cells.
+   * @param amap the used generalized map.
+   * @param adart a dart of the i-cell to contract.
+   * @return the number of deleted darts.
+   */
+  template<class Gmap, unsigned int i>
+  struct Contract_cell_functor
+  {
+    static size_t run(Gmap& amap, typename Gmap::Dart_handle adart)
+    {
+      CGAL_static_assertion ( 1<=i && i<=Gmap::dimension );
+      CGAL_assertion( (is_contractible<Gmap,i>(amap, adart)) );
+
+      size_t res = 0;
+
+      typename Gmap::Dart_handle d1, d2;
+      typename Gmap::Dart_handle dg1=amap.null_handle, dg2=amap.null_handle;
+
+      int mark = amap.get_new_mark();
+      int mark_modified_darts = amap.get_new_mark();
+
+      // First we store and mark all the darts of the i-cell to contract.
+      std::deque<typename Gmap::Dart_handle> to_erase;
+      for ( CGAL::GMap_dart_iterator_basic_of_cell<Gmap,i> it(amap,adart,mark);
+            it.cont(); ++it )
+      {
+        to_erase.push_back(it);
+        if ( !amap.template is_free<i-1>(it) && dg1==amap.null_handle )
+        { dg1=it; dg2=amap.template alpha<i-1>(it); }
+        amap.mark(it, mark);
+        ++res;
+      }
+
+      // We group the two (i-1)-cells incident if they exist.
+      if ( dg1!=amap.null_handle )
+         CGAL::internal::Group_attribute_functor_run<Gmap,i-1>::
+             run(&amap, dg1, dg2);
+
+      // During the operation, we store in modified_darts the darts modified
+      // to test after the loop the non void attributes that are split.
+      std::deque<typename Gmap::Dart_handle> modified_darts;
+
+      // For each dart of the i-cell, we modify i-links of neighbors.
+      typename std::deque<typename Gmap::Dart_handle>::iterator it =
+          to_erase.begin();
+      for ( ; it!=to_erase.end(); ++it )
+      {
+        d1 = amap.template alpha<i>(*it);
+        if ( !amap.is_marked(d1, mark) )
+        {
+          d2 = amap.template alpha<i-1,i>(*it);
+          while ( amap.is_marked(d2, mark) )
+          { d2 = amap.template alpha<i-1,i>(d2); }
+
+          if ( !amap.is_marked(d1, mark_modified_darts) )
+          {
+            CGAL_assertion( !amap.is_marked(d2, mark_modified_darts) );
+            amap.template basic_link_alpha<i>(d1, d2);
+            amap.mark(d1, mark_modified_darts);
+            modified_darts.push_back(d1);
+            // TODO push only one out of two dart ?
+            if ( d1!=d2 )
+            {
+              amap.mark(d2, mark_modified_darts);
+              modified_darts.push_back(d2);
+            }
+          }
+        }
+      }
+
+      // We test the split of all the incident cells for all the non
+      // void attributes.
+      Gmap::Helper::template Foreach_enabled_attributes_except
+        <CGAL::internal::Test_split_attribute_functor<Gmap,i>, i>::
+        run(&amap, modified_darts, mark_modified_darts);
+
+      // We remove all the darts of the i-cell.
+      for ( it=to_erase.begin(); it!=to_erase.end(); ++it )
+      { amap.erase_dart(*it); }
+
+      CGAL_assertion( amap.is_whole_map_unmarked(mark) );
+      amap.free_mark(mark);
+
+      // If no attribute is enabled (or if only i-attributes are enabled),
+      // the darts are not unmark by Foreach_enabled_attributes_except.
+      // Thus we unmark them now.
+      if ( !amap.is_whole_map_unmarked(mark_modified_darts) )
+      {
+        for ( it=modified_darts.begin(); it!=modified_darts.end(); ++it )
+          amap.unmark(*it, mark_modified_darts);
+      }
+
+      CGAL_assertion ( amap.is_whole_map_unmarked(mark_modified_darts) );
+      amap.free_mark(mark_modified_darts);
+
+#ifdef CGAL_GMAP_TEST_VALID_CONTRACTIONS
+      CGAL_assertion( amap.is_valid() );
+#endif
+
+      return res;
+    }
+  };
+
+  /** Contract an i-cell, 1<=i<=dimension.
+   * @param amap the used generalized map.
+   * @param adart a dart of the i-cell to remove.
+   * @return the number of deleted darts.
+   */
+  template < class Gmap, unsigned int i >
+  size_t contract_cell(Gmap& amap, typename Gmap::Dart_handle adart)
+  { return CGAL::Contract_cell_functor<Gmap,i>::run(amap,adart); }
+
+} // namespace CGAL
+
+#endif // CGAL_GENERALIZED_MAP_OPERATIONS_H //
+// EOF //

Generalized_map/include/CGAL/Generalized_map_storages.h

@@ -0,0 +1,359 @@
+// Copyright (c) 2014 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_GENERALIZED_MAP_STORAGES_H
+#define CGAL_GENERALIZED_MAP_STORAGES_H 1
+
+#include <CGAL/Combinatorial_map_storages.h>
+
+namespace CGAL {
+
+  /** @file Generalized_map_storages.h
+   * Definition of storages for dD Generalized map.
+   */
+
+  // Storage of darts with compact container, alpha with handles
+  template<unsigned int d_, class Items_, class Alloc_ >
+  class Generalized_map_storage_1
+  {
+  public:
+    typedef Generalized_map_storage_1<d_, Items_, Alloc_> Self;
+    typedef CGAL::Tag_false Use_index;
+
+    typedef internal::Combinatorial_map_helper<Self> Helper;
+
+    typedef typename Items_::template Dart_wrapper<Self>  Dart_wrapper;
+    typedef typename Dart_wrapper::Dart                   Dart;
+    typedef typename Alloc_::template rebind<Dart>::other Dart_allocator;
+
+    typedef Compact_container<Dart,Dart_allocator>  Dart_container;
+
+    typedef typename Dart_container::iterator       Dart_handle;
+    typedef typename Dart_container::const_iterator Dart_const_handle;
+    typedef typename Dart_container::size_type      size_type;
+
+    typedef CGAL::Void* Null_handle_type;
+    static Null_handle_type null_handle;
+
+    typedef Items_ Items;
+    typedef Alloc_ Alloc;
+
+    template <typename T>
+    struct Container_for_attributes :
+        public Compact_container<T, typename Alloc_::template rebind<T>::other>
+    {};
+
+    /// Typedef for attributes
+    typedef typename Dart_wrapper::Attributes Attributes;
+
+    template<int i>
+    struct Attribute_type: public Helper::template Attribute_type<i>
+    {};
+    template<int i>
+    struct Attribute_handle: public Helper::template Attribute_handle<i>
+    {};
+    template<int i>
+    struct Attribute_const_handle:
+      public Helper::template Attribute_const_handle<i>
+    {};
+    template<int i>
+    struct Attribute_range: public Helper::template Attribute_range<i>
+    {};
+    template<int i>
+    struct Attribute_const_range:
+      public Helper::template Attribute_const_range<i>
+    {};
+
+    /// Number of marks
+    static const size_type NB_MARKS = 32;
+
+    /// The dimension of the generalized map.
+    static const unsigned int dimension = d_;
+
+    typedef Handle_hash_function Hash_function;
+
+    // Init
+    void init_storage()
+    {}
+
+   /** Return if this dart is free for adimension.
+     * @param dh a dart handle
+     * @param i the dimension.
+     * @return true iff dh is linked with NULL for \em adimension.
+     */
+    template<unsigned int i>
+    bool is_free(Dart_const_handle dh) const
+    {
+      CGAL_assertion( dh!=NULL );
+      CGAL_assertion(i <= dimension);
+      return dh->malpha[i]==dh;
+    }
+    bool is_free(Dart_const_handle dh, unsigned int i) const
+    {
+      CGAL_assertion( dh!=NULL );
+      CGAL_assertion(i <= dimension);
+      return dh->malpha[i]==dh;
+    }
+
+    /// Set simultaneously all the marks of this dart to a given value.
+    void set_dart_marks(Dart_const_handle ADart,
+                        const std::bitset<NB_MARKS>& amarks) const
+    {
+      CGAL_assertion( ADart!=NULL );
+      ADart->set_marks(amarks);
+    }
+    /// Return all the marks of a dart.
+    std::bitset<NB_MARKS> get_dart_marks(Dart_const_handle ADart) const
+    {
+      CGAL_assertion( ADart!=NULL );
+      return ADart->get_marks();
+    }
+    /// Return the mark value of dart a given mark number.
+    bool get_dart_mark(Dart_const_handle ADart, int amark) const
+    {
+      CGAL_assertion( ADart!=NULL );
+      return ADart->get_mark(amark);
+    }
+
+    /// Set the mark of a given mark number to a given value.
+    void set_dart_mark(Dart_const_handle ADart, int amark, bool avalue) const
+    {
+      CGAL_assertion( ADart!=NULL );
+      ADart->set_mark(amark, avalue);
+    }
+
+    /// Flip the mark of a given mark number to a given value.
+    void flip_dart_mark(Dart_const_handle ADart, int amark) const
+    {
+      CGAL_assertion( ADart!=NULL );
+      ADart->flip_mark(amark);
+    }
+
+    // Access to alpha maps
+    Dart_handle get_alpha(Dart_handle ADart, int B1)
+    {
+      CGAL_assertion(ADart!=NULL && B1>=0 && B1<=(int)dimension);
+      return ADart->malpha[B1];
+    }
+    Dart_const_handle get_alpha(Dart_const_handle ADart, int B1) const
+    {
+      CGAL_assertion(ADart!=NULL && B1>=0 && B1<=(int)dimension);
+      return  ADart->malpha[B1];
+    }
+    template<int B1>
+    Dart_handle get_alpha(Dart_handle ADart)
+    {
+      CGAL_assertion(ADart!=NULL && B1>=0 && B1<=(int)dimension);
+      return  ADart->malpha[B1];
+    }
+    template<int B1>
+    Dart_const_handle get_alpha(Dart_const_handle ADart) const
+    {
+      CGAL_assertion(ADart!=NULL && B1>=0 && B1<=(int)dimension);
+      return  ADart->malpha[B1];
+    }
+
+    // return a handle on the i-attribute
+    template<unsigned int i>
+    typename Attribute_handle<i>::type attribute(Dart_handle ADart)
+    {
+      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+                     "attribute<i> called but i-attributes are disabled.");
+      return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
+        (ADart->mattribute_handles);
+    }
+    template<unsigned int i>
+    typename Attribute_const_handle<i>::type
+    attribute(Dart_const_handle ADart) const
+    {
+      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+                     "attribute<i> called but i-attributes are disabled.");
+      return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
+        (ADart->mattribute_handles);
+    }
+
+    // get the attribute given its handle
+    template<unsigned int i>
+    typename Attribute_type<i>::type&
+    get_attribute(typename Attribute_handle<i>::type ah)
+    {
+      CGAL_assertion( ah!=NULL );
+      return *ah;
+    }
+    template<unsigned int i>
+    const typename Attribute_type<i>::type&
+    get_attribute(typename Attribute_const_handle<i>::type ah) const
+    {
+      CGAL_assertion( ah!=NULL );
+      return *ah;
+    }
+
+    Dart & get_dart(Dart_handle ah)
+    {
+      CGAL_assertion( ah!=NULL );
+      return *ah;
+    }
+    const Dart & get_dart(Dart_const_handle ah) const
+    {
+      CGAL_assertion( ah!=NULL );
+      return *ah;
+    }
+
+    // Get the dart of the given attribute
+    template<unsigned int i>
+    Dart_handle dart_of_attribute(typename Attribute_handle<i>::type ah)
+    {
+      CGAL_assertion( ah!=NULL );
+      return ah->dart();
+    }
+    template<unsigned int i>
+    Dart_const_handle
+    dart_of_attribute(typename Attribute_const_handle<i>::type ah) const
+    {
+      CGAL_assertion( ah!=NULL );
+      return ah->dart();
+    }
+
+    // Set the dart of the given attribute
+    template<unsigned int i>
+    void set_dart_of_attribute(typename Attribute_handle<i>::type ah,
+                               Dart_handle adart)
+    {
+      CGAL_assertion( ah!=NULL );
+      ah->set_dart(adart);
+    }
+
+    // Get the info of the given attribute
+    template<unsigned int i>
+    typename Attribute_type<i>::type::Info &
+    info_of_attribute(typename Attribute_handle<i>::type ah)
+    {
+      CGAL_assertion( ah!=NULL );
+      return ah->info();
+    }
+    template<unsigned int i>
+    const typename Attribute_type<i>::type::Info &
+    info_of_attribute(typename Attribute_const_handle<i>::type ah) const
+    {
+      CGAL_assertion( ah!=NULL );
+      return ah->info();
+    }
+
+    // Get the info of the i-cell attribute associated with the given dart
+    template<unsigned int i>
+    typename Attribute_type<i>::type::Info & info(Dart_handle adart)
+    {
+      CGAL_assertion( adart!=NULL );
+      CGAL_assertion( attribute<i>(adart)!=NULL );
+      return info_of_attribute<i>(attribute<i>(adart));
+    }
+    template<unsigned int i>
+    const typename Attribute_type<i>::type::Info &
+    info(Dart_const_handle adart) const
+    {
+      CGAL_assertion( adart!=NULL );
+      CGAL_assertion( attribute<i>(adart)!=NULL );
+      return info_of_attribute<i>(attribute<i>(adart));
+    }
+
+    // Get the dart of the i-cell attribute associated with the given dart
+    template<unsigned int i>
+    Dart_handle & dart(Dart_handle adart)
+    {
+      CGAL_assertion( adart!=NULL );
+      CGAL_assertion( attribute<i>(adart)!=NULL );
+      return dart_of_attribute<i>(attribute<i>(adart));
+    }
+    template<unsigned int i>
+    Dart_const_handle dart(Dart_const_handle adart) const
+    {
+      CGAL_assertion( adart!=NULL );
+      CGAL_assertion( attribute<i>(adart)!=NULL );
+      return dart_of_attribute<i>(attribute<i>(adart));
+    }
+
+    void display_dart(Dart_const_handle ADart) const
+    { std::cout<<&*ADart; }
+
+    template<unsigned int i>
+    void display_attribute(typename Attribute_const_handle<i>::type ah) const
+    { std::cout<<&*ah; }
+
+  protected:
+    // Set the handle on the i th attribute
+    template<unsigned int i>
+    void basic_set_dart_attribute(Dart_handle dh,
+                                  typename Attribute_handle<i>::type ah)
+    {
+      CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
+        (dh->mattribute_handles) = ah;
+    }
+
+    /** Link a dart with a given dart for a given dimension.
+     * @param adart the dart to link.
+     * @param adart2 the dart to link with.
+     * @param i the dimension.
+     */
+    template<unsigned int i>
+    void dart_link_alpha(Dart_handle adart, Dart_handle adart2)
+    {
+      CGAL_assertion(i <= dimension);
+      CGAL_assertion(adart!=NULL && adart2!=NULL);
+      adart->malpha[i] = adart2;
+    }
+    void dart_link_alpha(Dart_handle adart, Dart_handle adart2, unsigned int i)
+    {
+      CGAL_assertion(i <= dimension);
+      CGAL_assertion(adart!=NULL && adart2!=NULL);
+      adart->malpha[i] = adart2;
+    }
+
+    /** Unlink a dart for a given dimension.
+     * @param adart a dart.
+     * @param i the dimension.
+     */
+    template<unsigned int i>
+    void dart_unlink_alpha(Dart_handle adart)
+    {
+      CGAL_assertion(adart!=NULL && i <= dimension);
+      adart->malpha[i] = adart;
+    }
+    void dart_unlink_alpha(Dart_handle adart, unsigned int i)
+    {
+      CGAL_assertion(adart!=NULL && i <= dimension);
+      adart->malpha[i] = adart;
+    }
+
+  protected:
+    /// Dart container.
+    Dart_container mdarts;
+
+    /// Tuple of attributes containers
+    typename Helper::Attribute_containers mattribute_containers;
+  };
+
+  /// null_handle
+  template < unsigned int d_, class Items_, class Alloc_ >
+  typename Generalized_map_storage_1<d_, Items_, Alloc_>::Null_handle_type
+  Generalized_map_storage_1<d_, Items_, Alloc_>::null_handle = NULL;
+
+} // namespace CGAL
+
+#endif // CGAL_GENERALIZED_MAP_STORAGES_H //
+// EOF //

Generalized_map/include/CGAL/internal/Generalized_map_group_functors.h

@@ -0,0 +1,426 @@
+// Copyright (c) 2014 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_GENERALIZED_MAP_GROUP_FUNCTORS_H
+#define CGAL_GENERALIZED_MAP_GROUP_FUNCTORS_H 1
+
+#include <CGAL/Unique_hash_map.h>
+#include <CGAL/internal/Generalized_map_internal_functors.h>
+#include <CGAL/GMap_dart_iterators.h>
+#include <CGAL/Combinatorial_map_functors.h>
+
+/* Definition of functors used to group/ungroup 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.
+ * These functors used other functors defined in Combinatorial_map_functors.h
+ *
+ * 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
+ *    darts are possibly modified.
+ *
+ * Group_attribute_functor_of_dart_run<CMap,i> same than
+ *   Group_attribute_functor_of_dart<CMap>::run<i>, with i template argument
+ *   given in the struct to enable specialization.
+ *
+ * Group_attribute_functor<CMap> to group the <i>-attributes of two
+ *    given i-cells (except for j-adim). If one i-attribute is NULL, we set the
+ *    darts of its i-cell to the second attribute. If both i-attributes are
+ *    non NULL, we overide all the i-attribute of the second i-cell to the
+ *    first i-attribute.
+ *
+ * Degroup_attribute_functor_run<CMap> to degroup one i-attributes in two
+ *   (except for j-adim).
+ *
+ * Test_split_attribute_functor<CMap,i> to test if there is some i-attributes
+ *   that are split after an operation. Modified darts are given in a
+ *   std::deque.
+ */
+namespace CGAL
+{
+namespace internal
+{
+// ************************************************************************
+/// Functor used for link_beta to update the i-attributes of
+/// dh2 on the attributes of dh1 dart, except if i=j.
+///    (j is the dimension of the beta modified between dh1 and dh2,
+///     so that after the modification we will have beta_j(dh1)==dh2)
+/// Only attributes of dh1 or dh2 can be modified. If one dart as its
+/// attribute equal to null, it takes the attributes of the second dart.
+/// If both attributes are non null, dh2 takes the attribute of dh1.
+template<typename CMap, unsigned int i, unsigned int j=CMap::dimension+1,
+         typename T=typename CMap::template Attribute_type<i>::type>
+struct Group_attribute_functor_of_dart_run
+{
+  /// Group the i-attribute of dh1 and dh2.
+  static void run(CMap* amap,
+                  typename CMap::Dart_handle dh1,
+                  typename CMap::Dart_handle dh2)
+  {
+    CGAL_static_assertion( i<=CMap::dimension );
+    CGAL_static_assertion( i!=j );
+    CGAL_static_assertion_msg(CMap::Helper::template
+                              Dimension_index<i>::value>=0,
+                              "Group_attribute_functor_of_dart_run<i> but "
+                              "i-attributes are disabled");
+    typename CMap::template Attribute_handle<i>::type
+        a1=amap->template attribute<i>(dh1);
+    typename CMap::template Attribute_handle<i>::type
+        a2=amap->template attribute<i>(dh2);
+
+    // If the two attributes are equal, nothing to do.
+    if ( a1==a2 ) return;
+
+    if ( a1==CMap::null_handle ) amap->template set_dart_attribute<i>(dh1, a2);
+    else amap->template set_dart_attribute<i>(dh2, a1);
+  }
+};
+// Specialization for i=j. Do nothing as j is the dimension to not consider.
+template<typename CMap, unsigned int i, typename T>
+struct Group_attribute_functor_of_dart_run<CMap,i,i,T>
+{
+  static void run(CMap*,
+                  typename CMap::Dart_handle,
+                  typename CMap::Dart_handle)
+  {}
+};
+// ************************************************************************
+/// Functor used for link_beta to update the attributes of
+/// adart2 on the attributes of this dart, except for j-attributes.
+///    (j is the dimension of the beta modified between adart1 and adart2,
+///     so that after the modification we will have beta_j(adart1)==adart2)
+/// We define run<i> to allows to use this functor with
+/// Foreach_enabled_attributes.
+///   If you know i at compiling time, use directly
+///   Group_attribute_functor_of_dart_run.
+template<typename CMap, unsigned int j=CMap::dimension+1>
+struct Group_attribute_functor_of_dart
+{
+  template <unsigned int i>
+  static void run(CMap* amap,
+                  typename CMap::Dart_handle adart1,
+                  typename CMap::Dart_handle adart2)
+  {
+    CGAL::internal::Group_attribute_functor_of_dart_run<CMap,i,j>::
+        run(amap,adart1,adart2);
+  }
+};
+// ************************************************************************
+// Functor used to group the two i-attributes of the two i-cells, except
+// the attribute of j
+//    (j is the dimension of the beta modified between adart1 and adart2).
+template<typename CMap, unsigned int i, unsigned int j=CMap::dimension+1,
+         typename T=typename CMap::template Attribute_type<i>::type>
+struct Group_attribute_functor_run
+{
+  static void run(CMap* amap,
+                  typename CMap::Dart_handle adart1,
+                  typename CMap::Dart_handle adart2)
+  {
+    CGAL_static_assertion( i<=CMap::dimension );
+    CGAL_static_assertion( i!=j );
+    CGAL_static_assertion_msg
+        ( CMap::Helper::template Dimension_index<i>::value>=0,
+          "Group_attribute_functor_run<i> but i-attributes are disabled" );
+    typename CMap::template Attribute_handle<i>::type
+        a1=amap->template attribute<i>(adart1);
+    typename CMap::template Attribute_handle<i>::type
+        a2=amap->template attribute<i>(adart2);
+
+    // If the two attributes are equal, nothing to do.
+    if ( a1 == a2 ) return;
+
+    typename CMap::Dart_handle toSet = amap->null_handle;
+
+    // If the attribute associated to adart1 is NULL, set it with
+    // the attribute associated to adart2 (necessarily != NULL)
+    if (a1 == CMap::null_handle)
+    { toSet  = adart1; a1 = a2; }
+    else
+    {
+      toSet = adart2;
+      if (a2 != CMap::null_handle)
+      {
+        CGAL::internal::Call_merge_functor<CMap, i>::run(amap, a1, a2);
+      }
+    }
+    amap->template set_attribute<i>(toSet, a1);
+  }
+};
+// Specialization for void attributes.
+template<typename CMap, unsigned int i, unsigned int j>
+struct Group_attribute_functor_run<CMap, i, j, CGAL::Void>
+{
+  static void run( CMap*,
+                   typename CMap::Dart_handle,
+                   typename CMap::Dart_handle )
+  {}
+};
+// Specialization for i=j. Do nothing as j is the dimension to not consider.
+template<typename CMap, unsigned int i, typename T>
+struct Group_attribute_functor_run<CMap,i,i,T>
+{
+  static void run(CMap*,
+                  typename CMap::Dart_handle,
+                  typename CMap::Dart_handle)
+  {}
+};
+// ************************************************************************
+/// Functor used for sew to update the attributes of
+/// adart2 on the attributes of this dart, except for j-attributes.
+///    (j is the dimension of the beta modified between adart1 and adart2,
+///     so that after the modification we will have beta_j(adart1)==adart2)
+/// We define run<i> to allows to use this functor with
+/// Foreach_enabled_attributes.
+///   If you know i at compiling time, use directly
+///   Group_attribute_functor_run.
+template<typename CMap, unsigned int j=CMap::dimension+1>
+struct Group_attribute_functor
+{
+  template <unsigned int i>
+  static void run(CMap* amap,
+                  typename CMap::Dart_handle adart1,
+                  typename CMap::Dart_handle adart2)
+  { CGAL::internal::Group_attribute_functor_run<CMap,i,j>::
+        run(amap,adart1,adart2); }
+};
+// ************************************************************************
+// Functor used to degroup one i-attribute of one i-cell in two, except the
+// attribute of j.
+template<typename CMap, unsigned int i, unsigned int j=CMap::dimension+1,
+         typename T=typename CMap::template Attribute_type<i>::type>
+struct Degroup_attribute_functor_run
+{
+  static void run(CMap* amap,
+                  typename CMap::Dart_handle adart1,
+                  typename CMap::Dart_handle adart2)
+  {
+    CGAL_static_assertion( i<=CMap::dimension );
+    CGAL_static_assertion( i!=j );
+    CGAL_static_assertion_msg
+        ( CMap::Helper::template Dimension_index<i>::value>=0,
+          "Degroup_attribute_functor_run<i> but i-attributes are disabled" );
+
+    typename CMap::template Attribute_handle<i>::type
+        a1=amap->template attribute<i>(adart1);
+
+    // If there is no first attribute, nothing to degroup.
+    if ( a1==CMap::null_handle ) return;
+
+    // If the second attribute is non null and already different from a1,
+    // nothing to do.
+    if ( a1!=amap->template attribute<i>(adart2) &&
+         amap->template attribute<i>(adart2)!=CMap::null_handle ) return;
+
+    CGAL_assertion( (!CGAL::belong_to_same_cell<CMap,i>
+                     (*amap, adart1, adart2)) );
+
+    // As we split, we set the dart of the first attribute to adart1 for which
+    // we are sure it belongs to the first i-cell.
+    amap->template get_attribute<i>(a1).set_dart(adart1);
+
+    typename CMap::template Attribute_handle<i>::type
+      a2 = amap->template
+      create_attribute<i>(amap->template get_attribute<i>(a1));
+
+    amap->template set_attribute<i>(adart2, a2);
+    CGAL::internal::Call_split_functor<CMap, i>::run(amap, a1, a2);
+  }
+};
+// Specialization for void attributes.
+template<typename CMap, unsigned int i, unsigned int j>
+struct Degroup_attribute_functor_run<CMap, i, j, CGAL::Void>
+{
+  static void run(CMap*,
+                  typename CMap::Dart_handle,
+                  typename CMap::Dart_handle)
+  {}
+};
+// Specialization for i==j.
+template<typename CMap, unsigned int i, typename T>
+struct Degroup_attribute_functor_run<CMap, i, i, T>
+{
+  static void run(CMap*,
+                  typename CMap::Dart_handle,
+                  typename CMap::Dart_handle)
+  {}
+};
+// ************************************************************************
+// Function used by Test_split_attribute_functor_run to process one dart.
+// Test the split of the i-cell containing the given dart adart.
+// When we process a dart, we search in the Unique_hash_map if its
+// i-attribute was already found. If yes, it means that we already
+// found an i-cell with this attribute, thus this attribute is split.
+// We mark (with mark) all the darts of the i-cell containing adart to
+// process them exactly once.
+template<typename CMap, unsigned int i>
+void test_split_attribute_functor_one_dart
+( CMap* amap, typename CMap::Dart_handle adart,
+  CGAL::Unique_hash_map<typename CMap::template Attribute_handle<i>::type,
+                        unsigned int, typename CMap::Hash_function> &
+  found_attributes, int mark )
+{
+  CGAL_assertion( amap!=NULL );
+  CGAL_static_assertion_msg(CMap::Helper::template
+                            Dimension_index<i>::value>=0,
+                            "Test_split_attribute_functor_one_dart<i> but "
+                            "i-attributes are disabled");
+
+  typedef typename CMap::template Attribute_handle<i>::type
+      Attribute_handle_i;
+
+  // If the current dart has no attribute, or if it is aldready marked,
+  // nothing to do.
+  if ( amap->template attribute<i>(adart)==CMap::null_handle ||
+       amap->is_marked(adart, mark) )
+    return;
+
+  Attribute_handle_i a1 = amap->template attribute<i>(adart);
+  if ( found_attributes.is_defined(a1) )
+  {  // Here the attribute was already present in the hash_map
+    Attribute_handle_i a2 = amap->template
+      create_attribute<i>(amap->template get_attribute<i>(a1));
+
+    for ( CGAL::GMap_dart_iterator_basic_of_cell<CMap, i>
+          itj(*amap, adart, mark); itj.cont(); ++itj )
+    {
+      amap->template set_dart_attribute<i>(itj, a2);
+      amap->mark(itj, mark);
+    }
+    CGAL::internal::Call_split_functor<CMap, i>::run(amap, a1, a2);
+  }
+  else
+  {
+    // Here the attribute was not in the hash_map.
+    found_attributes[a1]=1;
+    amap->template set_dart_of_attribute<i>(a1, adart);
+
+    for ( CGAL::GMap_dart_iterator_basic_of_cell<CMap, i>
+          itj(*amap, adart, mark); itj.cont(); ++itj )
+    {
+      CGAL_assertion( amap->template attribute<i>(itj)==a1 );
+      amap->mark(itj, mark);
+    }
+  }
+}
+// ************************************************************************
+/// Functor used for unsew to test if i-attributes are split after an
+/// operation, except for j-attributes.
+///   (j is the dimension of the beta modified for darts in modified_darts,
+///    if j==0 modified_darts2 are the darts modified for beta_1).
+template<typename CMap, unsigned int i, unsigned int j=CMap::dimension+1,
+         typename T=typename CMap::template Attribute_type<i>::type>
+struct Test_split_attribute_functor_run
+{
+  // modified_darts is the set of modified darts for beta_j
+  static void run( CMap* amap,
+                   const std::deque<typename CMap::Dart_handle>
+                   &modified_darts,
+                   int mark_modified_darts=-1)
+  {
+    CGAL_static_assertion( i<=CMap::dimension );
+    CGAL_assertion( i!=j );
+    CGAL_assertion( amap!=NULL );
+    CGAL_static_assertion_msg(CMap::Helper::template
+                              Dimension_index<i>::value>=0,
+                              "Test_split_attribute_functor_run<i> but "
+                              "i-attributes are disabled");
+
+    typedef typename CMap::template Attribute_handle<i>::type
+        Attribute_handle_i;
+
+    CGAL::Unique_hash_map<Attribute_handle_i, unsigned int,
+                          typename CMap::Hash_function> found_attributes;
+
+    int mark = amap->get_new_mark(); // to mark incident cells.
+    typename std::deque<typename CMap::Dart_handle>::const_iterator
+        it=modified_darts.begin();
+    for ( ; it!=modified_darts.end(); ++it )
+    {
+      CGAL::internal::test_split_attribute_functor_one_dart<CMap,i>
+          (amap, *it, found_attributes, mark);
+    }
+
+    // Now we unmark all the marked darts.
+    amap->negate_mark(mark);
+    for ( it=modified_darts.begin(); it!=modified_darts.end(); ++it )
+    {
+      if ( mark_modified_darts!=-1 )
+        amap->unmark(*it, mark_modified_darts);
+
+      if ( !amap->is_marked(*it, mark) )
+        CGAL::mark_cell<CMap, i>(*amap, *it, mark);
+    }
+
+    CGAL_assertion( amap->is_whole_map_marked(mark) );
+    amap->free_mark(mark);
+  }
+};
+// Specialization for void attributes.
+template<typename CMap, unsigned int i, unsigned int j>
+struct Test_split_attribute_functor_run<CMap, i, j, CGAL::Void>
+{
+  static void run( CMap*, const std::deque<typename CMap::Dart_handle>&,
+                   int=-1)
+  {}
+};
+// Specialization for i=j.
+template<typename CMap, unsigned int i, typename T>
+struct Test_split_attribute_functor_run<CMap, i, i, T>
+{
+  static void run( CMap*, const std::deque<typename CMap::Dart_handle>&,
+                   int=-1)
+  {}
+};
+// Specialization for i=1 and j=0 (edge attributes are not modified
+// when we modify beta_0).
+template<typename CMap, typename T>
+struct Test_split_attribute_functor_run<CMap, 1, 0, T>
+{
+  static void run( CMap*, const std::deque<typename CMap::Dart_handle>&,
+                   int=-1)
+  {}
+};
+// ************************************************************************
+/// Functor used for unsew to test if i-attributes are split after an
+/// operation, except for j-attributes.
+/// We define run<i> to allows to use this functor with
+/// Foreach_enabled_attributes.
+template<typename CMap, unsigned int j=CMap::dimension+1>
+struct Test_split_attribute_functor
+{
+  // Test the split of i-attributes, for all modified darts given in
+  // modified_darts, and marked with mark_modified_darts.
+  // For each split attribute, create a new i-attribute, associate
+  // it with the new i-cell and call onsplit functors.
+  template <unsigned int i>
+  static void run( CMap* amap,
+                   const std::deque<typename CMap::Dart_handle>
+                   &modified_darts,
+                   int mark_modified_darts=-1)
+  {
+    CGAL::internal::Test_split_attribute_functor_run<CMap, i, j>::
+        run(amap, modified_darts, mark_modified_darts);
+  }
+};
+// ************************************************************************
+} // namespace internal
+} // namespace CGAL
+
+#endif // CGAL_GENERALIZED_MAP_GROUP_FUNCTORS_H

Generalized_map/include/CGAL/internal/Generalized_map_internal_functors.h

@@ -0,0 +1,99 @@
+// Copyright (c) 2014 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_GENERALIZED_MAP_INTERNAL_FUNCTORS_H
+#define CGAL_GENERALIZED_MAP_INTERNAL_FUNCTORS_H
+
+/* Definition of functors used internally for generalized maps.
+ *
+ * internal::Alpha_functor<Dart, i...> to call several beta on the given dart.
+ *   Indices are given as parameter of the run function.
+ *
+ * internal::Alpha_functor_static<Dart, i...> to call several beta on the given
+ *   dart. Indices are given as template arguments.
+ *
+ */
+
+#include <CGAL/internal/Combinatorial_map_internal_functors.h>
+
+namespace CGAL
+{
+// ****************************************************************************
+namespace internal
+{
+// ****************************************************************************
+// Alpha functor, used to combine several alpha.
+#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
+template<typename CMap, typename Dart_handle, typename ... Alphas>
+struct Alpha_functor;
+
+template<typename CMap, typename Dart_handle>
+struct Alpha_functor<CMap, Dart_handle, int>
+{
+  static Dart_handle run(CMap* AMap, Dart_handle ADart, int B)
+  { return AMap->get_alpha(ADart, B); }
+};
+
+template<typename CMap, typename Dart_handle>
+struct Alpha_functor<CMap, Dart_handle, unsigned int>
+{
+  static Dart_handle run(CMap* AMap, Dart_handle ADart, unsigned int B)
+  { return  AMap->get_alpha(ADart, B); }
+};
+
+template<typename CMap, typename Dart_handle, typename ... Alphas>
+struct Alpha_functor<CMap, Dart_handle, int, Alphas...>
+{
+  static Dart_handle run(CMap* AMap, Dart_handle ADart, int B, Alphas... alphas)
+  { return Alpha_functor<CMap, Dart_handle, Alphas...>::
+      run(AMap, AMap->get_alpha(ADart, B), alphas...); }
+};
+
+template<typename CMap, typename Dart_handle, typename ... Alphas>
+struct Alpha_functor<CMap, Dart_handle, unsigned int, Alphas...>
+{
+  static Dart_handle run(CMap* AMap, Dart_handle ADart, unsigned int B,
+                         Alphas... alphas)
+  { return Alpha_functor<CMap, Dart_handle, Alphas...>::
+      run(AMap, AMap->get_alpha(ADart, B), alphas...); }
+};
+// ****************************************************************************
+template<typename CMap, typename Dart_handle, int ... Alphas>
+struct Alpha_functor_static;
+
+template<typename CMap, typename Dart_handle, int B>
+struct Alpha_functor_static<CMap, Dart_handle, B>
+{
+  static Dart_handle run(CMap* AMap, Dart_handle ADart)
+  { return AMap->template get_alpha<B>(ADart); }
+};
+
+template<typename CMap, typename Dart_handle, int B, int ... Alphas>
+struct Alpha_functor_static<CMap, Dart_handle, B, Alphas...>
+{
+  static Dart_handle run(CMap* AMap, Dart_handle ADart)
+  { return Alpha_functor_static<CMap, Dart_handle, Alphas...>::
+        run(AMap, AMap->template get_alpha<B>(ADart)); }
+};
+#endif //CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
+// ****************************************************************************
+} // namespace internal
+} // namespace CGAL
+
+#endif // CGAL_GENERALIZED_MAP_INTERNAL_FUNCTORS_H

Generalized_map/include/CGAL/internal/Generalized_map_sewable.h

@@ -0,0 +1,129 @@
+// Copyright (c) 2014 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_GENERALIZED_MAP_SEWABLE_H
+#define CGAL_GENERALIZED_MAP_SEWABLE_H
+
+#include <CGAL/GMap_dart_const_iterators.h>
+#include <CGAL/Unique_hash_map.h>
+
+/* Definition of functor used to test if two darts are i-sewable
+ * (we use functors as there are different specializations).
+ * @todo Specializations ?
+ */
+namespace CGAL
+{
+namespace internal
+{
+// Generic case (and for the moment the only one).
+template<typename CMap, unsigned int i, unsigned int dim=CMap::dimension>
+struct GMap_is_sewable_functor
+{
+  static bool run( const CMap* amap,
+                   typename CMap::Dart_const_handle adart1,
+                   typename CMap::Dart_const_handle adart2 )
+  {
+    CGAL_assertion( i<=CMap::dimension );
+    if ( !amap->template is_free<i>(adart1) ||
+         !amap->template is_free<i>(adart2) )
+      return false;
+
+    if ( adart1==adart2 )
+    {
+      if ( i==1 ) return true;
+      return false;
+    }
+
+    // hash map to build the isomorphism between the two i-cells.
+    CGAL::Unique_hash_map<typename CMap::Dart_const_handle,
+        typename CMap::Dart_const_handle,
+        typename CMap::Hash_function> bijection;
+
+    int m1 = amap->get_new_mark();
+    int m2 = amap->get_new_mark();
+    CGAL::GMap_dart_const_iterator_basic_of_involution<CMap,i>
+        I1(*amap, adart1, m1);
+    CGAL::GMap_dart_const_iterator_basic_of_involution<CMap,i>
+        I2(*amap, adart2, m2);
+    bool res = true;
+    int mbijection = amap->get_new_mark();
+
+    while ( res && I1.cont() && I2.cont() )
+    {
+      amap->mark(I1, mbijection);
+      bijection[I1]=I2;
+
+      CGAL_assertion( amap->template is_free<i>(I1) );
+      CGAL_assertion( amap->template is_free<i>(I2) );
+
+      // We can remove this constraint which is not required for
+      // combinatorial map definition, but which is quite "normal"
+      // Indeed in this case we try to i-sew an i-cell with itself (case
+      // of folded cells).
+      if ( I1==adart2 || I2==adart1 ) res=false;
+
+      for ( unsigned int j=0; res && j<=CMap::dimension; ++j )
+      {
+        if ( j+1!=i && j!=i && j!=i+1 )
+        {
+          if ( amap->is_free(I1,j) )
+          {
+            if ( !amap->is_free(I2,j) ) res=false;
+          }
+          else
+          {
+            if ( amap->is_free(I2,j) ) res=false;
+            else if ( amap->is_marked(amap->alpha(I1,j), mbijection) )
+            {
+              if ( bijection[amap->alpha(I1,j)]!=amap->alpha(I2,j) ) res=false;
+            }
+          }
+        }
+      }
+      ++I1; ++I2;
+    }
+    if ( I1.cont()!=I2.cont() )
+      res = false;
+
+    amap->negate_mark(m1);
+    amap->negate_mark(m2);
+    I1.rewind(); I2.rewind();
+    while ( amap->number_of_marked_darts(mbijection)>0 )
+    {
+      amap->unmark(I1, mbijection);
+      ++I1; ++I2;
+    }
+
+    CGAL_assertion( amap->is_whole_map_marked(m1) );
+    CGAL_assertion( amap->is_whole_map_marked(m2) );
+    CGAL_assertion( amap->is_whole_map_unmarked(mbijection) );
+    amap->free_mark(m1);
+    amap->free_mark(m2);
+    amap->free_mark(mbijection);
+
+    return res;
+  }
+};
+
+} //namespace internal
+
+} //namespace CGAL
+
+#endif // CGAL_COMBINATORIAL_MAP_SEWABLE_H
+//******************************************************************************

Generalized_map/package_info/Generalized_map/description.txt

@@ -0,0 +1 @@
+Generalized map in d-dimension

Generalized_map/package_info/Generalized_map/long_description.txt

@@ -0,0 +1,8 @@
+Implementation of generalized maps.
+
+A generalized map is a mathematical model allowing to represent  an
+object in any dimension by describing the subdivision of the object in
+vertices, edges, faces, volumes, ... and the  incidence relationships
+on them. Generalized maps allow to describe non orientable object,
+contrary to combinatorial maps. However, their main interest is their
+homogeneity in any dimension which simplify the algorithms.

Generalized_map/package_info/Generalized_map/maintainer

@@ -0,0 +1 @@
+Guillaume Damiand

Generalized_map/test/Generalized_map/CMakeLists.txt

@@ -0,0 +1,53 @@
+#  cd debug; cmake .. -DCMAKE_BUILD_TYPE=Debug
+#  cd release; cmake .. -DCMAKE_BUILD_TYPE=Release
+
+project( Generalized_map_test )
+
+CMAKE_MINIMUM_REQUIRED(VERSION 2.4.5)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
+set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS true)
+
+if ( COMMAND cmake_policy )
+  cmake_policy( SET CMP0003 NEW )
+endif()
+
+####################################################################################
+OPTION(BUILD_TESTS "Build tests." ON)
+
+if (BUILD_TESTS)
+  ENABLE_TESTING()
+  INCLUDE(CTest)
+
+  if (CMAKE_COMPILER_IS_GNUCXX)
+    SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g -O0 -Wall -W -Wshadow -Wunused-variable -Wunused-parameter -Wunused-function -Wunused -Wno-system-headers -Wno-deprecated -Woverloaded-virtual -Wwrite-strings -fprofile-arcs -ftest-coverage -frounding-math")
+  endif (CMAKE_COMPILER_IS_GNUCXX)
+  if (CMAKE_COMPILER_IS_GNUCC)
+    SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -g -O0 -Wall -W -fprofile-arcs -ftest-coverage -frounding-math")
+  endif (CMAKE_COMPILER_IS_GNUCC)
+endif (BUILD_TESTS)
+####################################################################################
+
+find_package(CGAL QUIET COMPONENTS Core )
+
+if ( NOT CGAL_FOUND )
+    message(FATAL_ERROR "This program requires the CGAL library, and will not be compiled.")
+endif ( NOT CGAL_FOUND )
+
+include( ${CGAL_USE_FILE} )
+
+# Try to use gcov but does not work... TODO
+#set(CMAKE_CXX_FLAGS "-g -frounding-math")
+#set(CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS})
+#add_definitions(-fprofile-arcs -ftest-coverage)
+
+#include( CGAL_CreateSingleSourceCGALProgram )
+include_directories(BEFORE  ../../include)
+add_executable(Generalized_map_test Generalized_map_test.cpp)
+#create_single_source_cgal_program( "Generalized_map_test.cpp" )
+target_link_libraries(Generalized_map_test ${CGAL_LIBRARIES}
+                                             ${CGAL_3RD_PARTY_LIBRARIES} )
+
+if (BUILD_TESTS)
+  ADD_TEST(Generalized_map_test "./Generalized_map_test")
+endif (BUILD_TESTS)

Generalized_map/test/Generalized_map/Generalized_map_2_test.h

@@ -0,0 +1,187 @@
+// Copyright (c) 2014 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_GENERALIZED_MAP_2_TEST
+#define CGAL_GENERALIZED_MAP_2_TEST 1
+
+#include <CGAL/Generalized_map_constructors.h>
+#include <CGAL/Generalized_map_operations.h>
+
+#include <CGAL/IO/Polyhedron_iostream.h>
+#include <iostream>
+#include <fstream>
+
+using namespace std;
+
+// #define GMAP_TRACE_TEST_BEGIN 1
+
+void trace_test_begin()
+{
+#ifdef GMAP_TRACE_TEST_BEGIN
+  static unsigned int nbtest = 0;
+
+  std::cout<<"Test "<<nbtest++<<" ..."<<std::flush;
+#endif
+}
+
+void trace_test_end()
+{
+#ifdef GMAP_TRACE_TEST_BEGIN
+  std::cout<<"Ok."<<std::endl;
+#endif
+}
+
+void trace_display_msg(const char*
+#ifdef GMAP_TRACE_TEST_BEGIN
+                       msg
+#endif
+                       )
+{
+#ifdef GMAP_TRACE_TEST_BEGIN
+  std::cout<<"***************** "<<msg<<"***************** "<<std::endl;
+#endif
+}
+
+template<typename GMAP>
+bool check_number_of_cells_2(GMAP& gmap, unsigned int nbv, unsigned int nbe,
+                             unsigned int nbf, unsigned int nbcc)
+{
+  if ( !gmap.is_valid() )
+    {
+      std::cout<<"ERROR: the gmap is not valid."<<std::endl;
+      assert(false);
+      return false;
+    }
+
+  std::vector<unsigned int> nbc;
+  nbc=gmap.count_all_cells();
+
+  if (nbv!=nbc[0] || nbe!=nbc[1] || nbf!=nbc[2] || nbcc!=nbc[3])
+    {
+      std::cout<<"ERROR: the number of cells is not correct. We must have "
+               <<" ("<<nbv<<", "<<nbe<<", "<<nbf<<", "<<nbcc<<") and we have"
+               <<" ("<<nbc[0]<<", "<<nbc[1]<<", "<<nbc[2]<<", "<<nbc[3]<<")."
+               <<std::endl;
+      assert(false);
+      return false;
+    }
+
+  trace_test_end();
+
+  return true;
+}
+
+template<class Gmap>
+bool test_GMAP_2()
+{
+  Gmap gmap;
+
+  typedef typename Gmap::Dart_handle Dart_handle;
+
+  // Construction operations
+  trace_test_begin();
+  Dart_handle dh1=CGAL::make_edge(gmap);
+  Dart_handle dh2=CGAL::make_edge(gmap);
+  Dart_handle dh3=CGAL::make_edge(gmap);
+  if ( !check_number_of_cells_2(gmap, 6, 3, 3, 3) )
+    return false;
+
+  trace_test_begin();
+  gmap.template sew<1>(dh1,dh2);
+  gmap.template sew<1>(gmap.alpha(dh2, 0),dh3);
+  if ( !check_number_of_cells_2(gmap, 4, 3, 1, 1) )
+    return false;
+
+  trace_test_begin();
+  Dart_handle dh5=CGAL::make_combinatorial_polygon(gmap, 3);
+  Dart_handle dh6=CGAL::make_combinatorial_polygon(gmap, 3);
+  if ( !check_number_of_cells_2(gmap, 10, 9, 3, 3) )
+    return false;
+
+  trace_test_begin();
+  gmap.template sew<2>(dh5,dh6);
+  if ( !check_number_of_cells_2(gmap, 8, 8, 3, 2) )
+    return false;
+
+  trace_test_begin();
+  dh5=gmap.template alpha<1>(dh5);
+  dh6=gmap.template alpha<1>(dh6);
+  CGAL::contract_cell<Gmap, 1>(gmap, gmap.template alpha<1>(dh5));
+  if ( !check_number_of_cells_2(gmap, 8, 7, 3, 3) )
+    return false;
+
+  trace_test_begin();
+  CGAL::contract_cell<Gmap, 2>(gmap, dh6);
+  if ( !check_number_of_cells_2(gmap, 6, 5, 2, 2) )
+    return false;
+
+  trace_test_begin();
+  CGAL::contract_cell<Gmap, 1>(gmap, gmap.template alpha<1>(dh5));
+  if ( !check_number_of_cells_2(gmap, 5, 4, 2, 2) )
+    return false;
+
+  trace_test_begin();
+  CGAL::contract_cell<Gmap, 1>(gmap, dh5);
+  if ( !check_number_of_cells_2(gmap, 4, 3, 1, 1) )
+    return false;
+
+  trace_test_begin();
+  CGAL::contract_cell<Gmap, 1>(gmap, dh2);
+  if ( !check_number_of_cells_2(gmap, 3, 2, 1, 1) )
+    return false;
+
+  trace_test_begin();
+  CGAL::contract_cell<Gmap, 1>(gmap, dh1);
+  if ( !check_number_of_cells_2(gmap, 2, 1, 1, 1) )
+    return false;
+
+  trace_test_begin();
+  CGAL::contract_cell<Gmap, 1>(gmap, dh3);
+  if ( !check_number_of_cells_2(gmap, 0, 0, 0, 0) )
+    return false;
+
+  trace_test_begin();
+  Dart_handle dh7=CGAL::make_combinatorial_hexahedron(gmap); // f1
+  Dart_handle dh8=gmap.template alpha<2,1,0,1,2>(dh7); // f2 opposite to f1
+  Dart_handle dh9=gmap.template alpha<2>(dh7); // face incident to f1 and d2
+
+  CGAL::remove_cell<Gmap,2>(gmap, dh7);
+  if ( !check_number_of_cells_2(gmap, 8, 12, 5, 1) )
+    return false;
+
+  trace_test_begin();
+  CGAL::remove_cell<Gmap,2>(gmap, dh8);
+  if ( !check_number_of_cells_2(gmap, 8, 12, 4, 1) )
+    return false;
+
+  trace_test_begin();
+  gmap.template close<2>();
+  if ( !check_number_of_cells_2(gmap, 8, 12, 6, 1) )
+    return false;
+  if ( !CGAL::is_volume_combinatorial_hexahedron(gmap, dh9) )
+  {
+    std::cout<<"Error: the closed volume is not a combinatorial hexahedron.\n";
+    assert(false);
+    return false;
+  }
+
+  return true;
+}
+
+#endif // CGAL_GENERALIZED_MAP_2_TEST

Generalized_map/test/Generalized_map/Generalized_map_3_test.h

@@ -0,0 +1,165 @@
+// Copyright (c) 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_GMAP_3_TEST_H
+#define CGAL_GMAP_3_TEST_H
+
+#include "Generalized_map_2_test.h"
+
+#include <iostream>
+#include <fstream>
+
+using namespace std;
+
+template<typename GMAP>
+bool check_number_of_cells_3(GMAP& gmap, unsigned int nbv, unsigned int nbe,
+                             unsigned int nbf, unsigned int nbvol,
+                             unsigned int nbcc)
+{
+  if ( !gmap.is_valid() )
+  {
+    std::cout<<"ERROR: the gmap is not valid."<<std::endl;
+    assert(false);
+    return false;
+  }
+
+  std::vector<unsigned int> nbc;
+  nbc=gmap.count_all_cells();
+
+  if (nbv!=nbc[0] || nbe!=nbc[1] || nbf!=nbc[2] || nbvol!=nbc[3] ||
+      nbcc!=nbc[4])
+  {
+    std::cout<<"ERROR: the number of cells is not correct. We must have "
+             <<" ("<<nbv<<", "<<nbe<<", "<<nbf<<", "<<nbvol<<", "<<nbcc
+             <<") and we have"<<" ("<<nbc[0]<<", "<<nbc[1]<<", "<<nbc[2]<<", "
+             <<nbc[3]<<", "<<nbc[4]<<")."
+             <<std::endl;
+    assert(false);
+    return false;
+  }
+
+  trace_test_end();
+
+  return true;
+}
+
+template<typename GMAP>
+bool test_GMAP_3()
+{
+  GMAP gmap;
+
+  typedef typename GMAP::Dart_handle Dart_handle;
+
+  // Construction operations
+  trace_test_begin();
+  Dart_handle dh1=CGAL::make_edge(gmap);
+  Dart_handle dh2=CGAL::make_edge(gmap);
+  Dart_handle dh3=CGAL::make_edge(gmap);
+  if ( !check_number_of_cells_3(gmap, 6, 3, 3, 3, 3) )
+    return false;
+
+  trace_test_begin();
+  gmap.template sew<1>(dh1,dh2);
+  gmap.template sew<1>(gmap.alpha(dh2,0),dh3);
+  if ( !check_number_of_cells_3(gmap, 4, 3, 1, 1, 1) )
+    return false;
+
+  trace_test_begin();
+  Dart_handle dh5=CGAL::make_combinatorial_polygon(gmap, 3);
+  Dart_handle dh6=CGAL::make_combinatorial_polygon(gmap, 3);
+  if ( !check_number_of_cells_3(gmap, 10, 9, 3, 3, 3) )
+    return false;
+
+  trace_test_begin();
+  gmap.template sew<2>(dh5,dh6);
+  if ( !check_number_of_cells_3(gmap, 8, 8, 3, 2, 2) )
+    return false;
+
+  trace_test_begin();
+  gmap.clear();
+  Dart_handle dh7=CGAL::make_combinatorial_hexahedron(gmap); // f1
+  Dart_handle dh8=gmap.template alpha<2,1,0,1,2>(dh7); // f2 opposite to f1
+  Dart_handle dh9=gmap.template alpha<2>(dh7); // face incident to f1 and d2
+
+  CGAL::remove_cell<GMAP,2>(gmap, dh7);
+  if ( !check_number_of_cells_3(gmap, 8, 12, 5, 1, 1) )
+    return false;
+
+  trace_test_begin();
+  CGAL::remove_cell<GMAP,2>(gmap, dh8);
+  if ( !check_number_of_cells_3(gmap, 8, 12, 4, 1, 1) )
+    return false;
+
+  trace_test_begin();
+  Dart_handle dh10=CGAL::make_combinatorial_hexahedron(gmap);
+  gmap.template sew<3>(dh9,dh10);
+  if ( !check_number_of_cells_3(gmap, 12, 20, 9, 2, 1) )
+    return false;
+
+  trace_test_begin();
+  GMAP gmap2(gmap);
+  if ( !check_number_of_cells_3(gmap2, 12, 20, 9, 2, 1) )
+    return false;
+  if ( !gmap.is_isomorphic_to(gmap2) )
+  {
+    std::cout<<"Error: gmap and gmap2 are not isomorphic (after copy).\n";
+    assert(false);
+    return false;
+  }
+
+  trace_test_begin();
+  gmap.template close<2>();
+  if ( !check_number_of_cells_3(gmap, 12, 20, 11, 2, 1) )
+    return false;
+  if ( !CGAL::is_volume_combinatorial_hexahedron(gmap, dh9) )
+  {
+    std::cout<<"Error: the closed volume is not a combinatorial hexahedron.\n";
+    assert(false);
+    return false;
+  }
+
+  trace_test_begin();
+  gmap.template close<3>();
+  if ( !check_number_of_cells_3(gmap, 12, 20, 11, 3, 1) )
+    return false;
+
+  trace_test_begin();
+  CGAL::remove_cell<GMAP,3>(gmap, gmap.alpha(dh9, 2, 3));
+  if ( !check_number_of_cells_3(gmap, 12, 20, 11, 2, 1) )
+    return false;
+
+  trace_test_begin();
+  CGAL::remove_cell<GMAP,2>(gmap, gmap.alpha(dh9, 2));
+  CGAL::remove_cell<GMAP,2>(gmap, gmap.alpha(dh9, 1, 0, 1, 2));
+  if ( !check_number_of_cells_3(gmap, 12, 20, 9, 2, 1) )
+    return false;
+  if ( !gmap.is_isomorphic_to(gmap2) )
+  {
+    std::cout<<"Error: gmap and gmap2 are not isomorphic (after close and removals).\n";
+    assert(false);
+    return false;
+  }
+
+
+
+  return true;
+}
+
+
+#endif // CGAL_GMAP_3_TEST_H

Generalized_map/test/Generalized_map/Generalized_map_4_test.h

@@ -0,0 +1,450 @@
+// Copyright (c) 2014 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_GMAP_4_TEST_H
+#define CGAL_GMAP_4_TEST_H
+
+#include <CGAL/Generalized_map_operations.h>
+#include "Generalized_map_2_test.h"
+
+template<typename GMAP>
+bool check_number_of_cells_4(GMAP& gmap, unsigned int nbv, unsigned int nbe,
+                             unsigned int nbf, unsigned int nbvol,
+                             unsigned int nbhvol, unsigned int nbcc)
+{
+  if ( !gmap.is_valid() )
+    {
+      std::cout<<"ERROR: the gmap is not valid."<<std::endl;
+      assert(false);
+      return false;
+    }
+
+  std::vector<unsigned int> nbc;
+  nbc=gmap.count_all_cells();
+
+  if (nbv!=nbc[0] || nbe!=nbc[1] || nbf!=nbc[2] || nbvol!=nbc[3] ||
+      nbhvol!=nbc[4] || nbcc!=nbc[5])
+    {
+      std::cout<<"ERROR: the number of cells is not correct. We must have "
+               <<" ("<<nbv<<", "<<nbe<<", "<<nbf<<", "<<nbvol<<", "<<nbhvol
+               <<", "<<nbcc<<") and we have"<<" ("<<nbc[0]<<", "<<nbc[1]<<", "
+               <<nbc[2]<<", "<<nbc[3]<<", "<<nbc[4]<<", "<<nbc[5]<<")."
+               <<std::endl;
+      assert(false);
+      return false;
+    }
+
+  trace_test_end();
+
+  return true;
+}
+
+template<typename GMAP>
+bool test_GMAP_4()
+{
+  GMAP gmap;
+
+  typedef typename GMAP::Dart_handle Dart_handle;
+
+  // Construction operations
+  trace_test_begin();
+  Dart_handle dh1=CGAL::make_edge(gmap);
+  Dart_handle dh2=CGAL::make_edge(gmap);
+  Dart_handle dh3=CGAL::make_edge(gmap);
+  if ( !check_number_of_cells_4(gmap, 6, 3, 3, 3, 3, 3) )
+    return false;
+
+  trace_test_begin();
+  gmap.template sew<1>(dh1,dh2);
+  gmap.template sew<1>(gmap.alpha(dh2,0),dh3);
+  if ( !check_number_of_cells_4(gmap, 4, 3, 1, 1, 1, 1) )
+    return false;
+
+  trace_test_begin();
+  Dart_handle dh5=CGAL::make_combinatorial_polygon(gmap, 3);
+  Dart_handle dh6=CGAL::make_combinatorial_polygon(gmap, 3);
+  if ( !check_number_of_cells_4(gmap, 10, 9, 3, 3, 3, 3) )
+    return false;
+
+  trace_test_begin();
+  gmap.template sew<2>(dh5,dh6);
+  if ( !check_number_of_cells_4(gmap, 8, 8, 3, 2, 2, 2) )
+    return false;
+
+  trace_test_begin();
+  gmap.clear();
+  Dart_handle dh7=CGAL::make_combinatorial_hexahedron(gmap); // f1
+  Dart_handle dh8=gmap.template alpha<2,1,0,1,2>(dh7); // f2 opposite to f1
+  Dart_handle dh9=gmap.template alpha<2>(dh7); // face incident to f1 and d2
+
+  CGAL::remove_cell<GMAP,2>(gmap, dh7);
+  if ( !check_number_of_cells_4(gmap, 8, 12, 5, 1, 1, 1) )
+    return false;
+
+  trace_test_begin();
+  CGAL::remove_cell<GMAP,2>(gmap, dh8);
+  if ( !check_number_of_cells_4(gmap, 8, 12, 4, 1, 1, 1) )
+    return false;
+
+  trace_test_begin();
+  Dart_handle dh10=CGAL::make_combinatorial_hexahedron(gmap);
+  gmap.template sew<3>(dh9,dh10);
+  if ( !check_number_of_cells_4(gmap, 12, 20, 9, 2, 1, 1) )
+    return false;
+
+  trace_test_begin();
+  Dart_handle dh11=CGAL::make_combinatorial_hexahedron(gmap);
+  gmap.template sew<4>(dh10,dh11);
+  if ( !check_number_of_cells_4(gmap, 12, 20, 9, 2, 2, 1) )
+    return false;
+
+  trace_test_begin();
+  GMAP gmap2(gmap);
+  if ( !check_number_of_cells_4(gmap2, 12, 20, 9, 2, 2, 1) )
+    return false;
+  if ( !gmap.is_isomorphic_to(gmap2) )
+  {
+    std::cout<<"Error: gmap and gmap2 are not isomorphic (after copy).\n";
+    assert(false);
+    return false;
+  }
+
+  trace_test_begin();
+  gmap.template close<2>();
+  if ( !check_number_of_cells_4(gmap, 12, 20, 11, 2, 2, 1) )
+    return false;
+  if ( !CGAL::is_volume_combinatorial_hexahedron(gmap, dh9) )
+  {
+    std::cout<<"Error: the closed volume is not a combinatorial hexahedron.\n";
+    assert(false);
+    return false;
+  }
+
+  trace_test_begin();
+  gmap.template close<3>();
+  if ( !check_number_of_cells_4(gmap, 12, 20, 11, 4, 2, 1) )
+    return false;
+
+  trace_test_begin();
+  gmap.template close<4>();
+  if ( !check_number_of_cells_4(gmap, 12, 20, 11, 4, 3, 1) )
+    return false;
+
+  trace_test_begin();
+  CGAL::remove_cell<GMAP,4>(gmap, gmap.alpha(dh9, 2, 3, 4));
+  if ( !check_number_of_cells_4(gmap, 12, 20, 11, 4, 2, 1) )
+    return false;
+
+  trace_test_begin();
+  CGAL::remove_cell<GMAP,3>(gmap, gmap.alpha(dh9, 2, 3));
+  CGAL::remove_cell<GMAP,3>(gmap, gmap.alpha(dh10, 2, 4, 3));
+  if ( !check_number_of_cells_4(gmap, 12, 20, 11, 2, 2, 1) )
+    return false;
+
+  trace_test_begin();
+  CGAL::remove_cell<GMAP,2>(gmap, gmap.alpha(dh9, 2));
+  CGAL::remove_cell<GMAP,2>(gmap, gmap.alpha(dh9, 1, 0, 1, 2));
+  if ( !check_number_of_cells_4(gmap, 12, 20, 9, 2, 2, 1) )
+    return false;
+
+  if ( !gmap.is_isomorphic_to(gmap2) )
+  {
+    std::cout<<"Error: gmap and gmap2 are not isomorphic (after close and removals).\n";
+    assert(false);
+    return false;
+  }
+
+
+/*  trace_test_begin();
+  Dart_handle dh7=gmap.template insert_barycenter_in_cell<1>(dh1);
+  if ( !check_number_of_cells_4(gmap, 9, 9, 6, 2, 2, 2) )
+    return false;
+
+  trace_test_begin();
+  Dart_handle dh8=gmap.template insert_barycenter_in_cell<2>(dh5);
+  if ( !check_number_of_cells_4(gmap, 10, 12, 8, 2, 2, 2) )
+    return false;
+
+  trace_test_begin();
+  Dart_handle dh9=gmap.template insert_point_in_cell<1>(dh2,apoint<GMAP>(1,0,3,0));
+  if ( !check_number_of_cells_4(gmap, 11, 13, 8, 2, 2, 2) )
+    return false;
+
+  trace_test_begin();
+  Dart_handle dh10=gmap.template insert_point_in_cell<2>(dh6,apoint<GMAP>(6,5,3,0));
+  if ( !check_number_of_cells_4(gmap, 12, 16, 10, 2, 2, 2) )
+    return false;
+
+  trace_test_begin();
+  Dart_handle dh11=gmap.insert_dangling_cell_1_in_cell_2(dh8,apoint<GMAP>(6,5.2,3,0));
+  if ( !check_number_of_cells_4(gmap, 13, 17, 10, 2, 2, 2) )
+    return false;
+
+  trace_test_begin();
+  Dart_handle dh12 = gmap.make_tetrahedron(apoint<GMAP>(-1, 0, 0,0),apoint<GMAP>(0, 2, 0,0),
+                                          apoint<GMAP>(1, 0, 0,0),apoint<GMAP>(1, 1, 2,0));
+  Dart_handle dh13 = gmap.make_tetrahedron(apoint<GMAP>(0, 2, -1,0),apoint<GMAP>(-1, 0, -1,0),
+                                          apoint<GMAP>(1, 0, -1,0),apoint<GMAP>(1, 1, -3,0));
+  if ( !check_number_of_cells_4(gmap, 21, 29, 18, 4, 4, 4) )
+    return false;
+
+  trace_test_begin();
+  gmap.template sew<3>(dh12, dh13);
+  if ( !check_number_of_cells_4(gmap, 18, 26, 17, 4, 3, 3) )
+    return false;
+
+  trace_test_begin();
+  Dart_handle dh14=gmap.template insert_barycenter_in_cell<2>(dh12);
+  if ( !check_number_of_cells_4(gmap, 19, 29, 19, 4, 3, 3) )
+    return false;
+
+  trace_test_begin();
+  Dart_handle dh15=gmap.template insert_barycenter_in_cell<1>(dh14);
+  if ( !check_number_of_cells_4(gmap, 20, 30, 19, 4, 3, 3) )
+    return false;
+
+  trace_test_begin();
+  gmap.template sew<4>(dh12, dh13);
+  if ( !check_number_of_cells_4(gmap, 19, 27, 16, 3, 3, 3) )
+    return false;
+
+  trace_test_begin();
+  Dart_handle dh16=gmap.template insert_barycenter_in_cell<1>(dh15);
+  if ( !check_number_of_cells_4(gmap, 20, 28, 16, 3, 3, 3) )
+    return false;
+
+  trace_test_begin();
+  Dart_handle dh17=gmap.template insert_barycenter_in_cell<2>(dh16);
+  if ( !check_number_of_cells_4(gmap, 21, 33, 20, 3, 3, 3) )
+    return false;
+
+  // Removal operations
+  trace_test_begin();
+  std::stack<Dart_handle> toremove;
+  for ( typename GMAP::template Dart_of_cell_range<0,2>::iterator
+          it=gmap.template darts_of_cell<0,2>(dh17).begin(),
+          itend=gmap.template darts_of_cell<0,2>(dh17).end();
+          it!=itend; ++it )
+    toremove.push( it );
+  while ( !toremove.empty() )
+  {
+    CGAL::remove_cell<GMAP,1>(gmap, toremove.top());
+    toremove.pop();
+  }
+  if ( !check_number_of_cells_4(gmap, 20, 28, 16, 3, 3, 3) )
+    return false;
+
+  trace_test_begin();
+  CGAL::remove_cell<GMAP,0>(gmap, dh16);
+  if ( !check_number_of_cells_4(gmap, 19, 27, 16, 3, 3, 3) )
+    return false;
+
+  trace_test_begin();
+  gmap.template unsew<4>(dh12);
+  if ( !check_number_of_cells_4(gmap, 20, 30, 19, 4, 3, 3) )
+    return false;
+
+  trace_test_begin();
+  CGAL::remove_cell<GMAP,0>(gmap, dh15);
+  if ( !check_number_of_cells_4(gmap, 19, 29, 19, 4, 3, 3) )
+    return false;
+
+  trace_test_begin();
+  CGAL::remove_cell<GMAP,1>(gmap, gmap.beta(dh14,2,1));
+  CGAL::remove_cell<GMAP,1>(gmap, gmap.beta(dh14,0));
+  CGAL::remove_cell<GMAP,1>(gmap, dh14);
+  if ( !check_number_of_cells_4(gmap, 18, 26, 17, 4, 3, 3) )
+    return false;
+
+  trace_test_begin();
+  gmap.template unsew<3>(dh12);
+  if ( !check_number_of_cells_4(gmap, 21, 29, 18, 4, 4, 4) )
+    return false;
+
+  trace_test_begin();
+  CGAL::remove_cell<GMAP,3>(gmap, dh13);
+  CGAL::remove_cell<GMAP,3>(gmap, dh12);
+  if ( !check_number_of_cells_4(gmap, 13, 17, 10, 2, 2, 2) )
+    return false;
+
+  trace_test_begin();
+  CGAL::remove_cell<GMAP,1>(gmap, dh11);
+  if ( !check_number_of_cells_4(gmap, 12, 16, 10, 2, 2, 2) )
+    return false;
+
+  trace_test_begin();
+  for ( typename GMAP::template Dart_of_cell_range<0,2>::iterator
+          it=gmap.template darts_of_cell<0,2>(dh10).begin(),
+          itend=gmap.template darts_of_cell<0,2>(dh10).end();
+          it!=itend; ++it )
+    toremove.push( it );
+  while ( !toremove.empty() )
+  {
+    CGAL::remove_cell<GMAP,1>(gmap, toremove.top());
+    toremove.pop();
+  }
+  if ( !check_number_of_cells_4(gmap, 11, 13, 8, 2, 2, 2) )
+    return false;
+
+  trace_test_begin();
+  CGAL::remove_cell<GMAP,0>(gmap, dh9);
+  if ( !check_number_of_cells_4(gmap, 10, 12, 8, 2, 2, 2) )
+    return false;
+
+  trace_test_begin();
+  for ( typename GMAP::template Dart_of_cell_range<0,2>::iterator
+          it=gmap.template darts_of_cell<0,2>(dh8).begin(),
+          itend=gmap.template darts_of_cell<0,2>(dh8).end();
+        it!=itend; ++it )
+    toremove.push( it );
+  while ( !toremove.empty() )
+  {
+    CGAL::remove_cell<GMAP,1>(gmap, toremove.top());
+    toremove.pop();
+  }
+  if ( !check_number_of_cells_4(gmap, 9, 9, 6, 2, 2, 2) )
+    return false;
+
+  trace_test_begin();
+  CGAL::remove_cell<GMAP,0>(gmap, dh7);
+  if ( !check_number_of_cells_4(gmap, 8, 8, 6, 2, 2, 2) )
+    return false;
+
+  trace_test_begin();
+  gmap.template unsew<2>(dh5);
+  if ( !check_number_of_cells_4(gmap, 10, 9, 6, 3, 3, 3) )
+    return false;
+
+  trace_test_begin();
+  CGAL::remove_cell<GMAP,2>(gmap, dh6);
+  CGAL::remove_cell<GMAP,2>(gmap, dh5);
+  if ( !check_number_of_cells_4(gmap, 4, 3, 4, 1, 1, 1) )
+    return false;
+
+  trace_test_begin();
+  gmap.template unsew<1>(dh2);
+  if ( !check_number_of_cells_4(gmap, 5, 3, 5, 2, 2, 2) )
+    return false;
+
+  trace_test_begin();
+  gmap.template unsew<0>(dh2);
+  if ( !check_number_of_cells_4(gmap, 6, 3, 6, 3, 3, 3) )
+    return false;
+
+  trace_test_begin();
+  CGAL::remove_cell<GMAP,1>(gmap, dh1);
+  CGAL::remove_cell<GMAP,1>(gmap, dh2);
+  CGAL::remove_cell<GMAP,1>(gmap, dh3);
+  if ( !check_number_of_cells_4(gmap, 0, 0, 0, 0, 0, 0) )
+    return false;
+
+  trace_test_begin();
+  dh1 = gmap.make_tetrahedron(apoint<GMAP>(-1, 0, 0,0),apoint<GMAP>(0, 2, 0,0),
+                             apoint<GMAP>(1, 0, 0,0),apoint<GMAP>(1, 1, 2,0));
+  dh2 = gmap.make_tetrahedron(apoint<GMAP>(0, 2, -1,0),apoint<GMAP>(-1, 0, -1,0),
+                             apoint<GMAP>(1, 0, -1,0),apoint<GMAP>(1, 1, -3,0));
+
+  if ( !gmap.template is_sewable<4>(dh1, dh2) )
+  {
+    std::cout<<"ERROR: the two 3-cells are not sewable."<<std::endl;
+    assert(false);
+    return false;
+  }
+  trace_test_end();
+
+  trace_test_begin();
+  dh3 = gmap.beta(dh1,2);
+  dh5 = gmap.template beta<1, 2>(dh1);
+
+  gmap.template unsew<2>(dh3);
+  gmap.template unsew<2>(dh5);
+  gmap.template sew<2>(dh1, dh5);
+  gmap.template sew<2>(gmap.beta(dh1,1), dh3);
+
+  if ( gmap.template is_sewable<4>(dh1, dh2) )
+  {
+    std::cout<<"ERROR: the two 3-cells are sewable."<<std::endl;
+    assert(false);
+    return false;
+  }
+  trace_test_end();
+
+  trace_test_begin();
+  gmap.clear();
+  dh1 = gmap.make_tetrahedron(apoint<GMAP>(-1, 0, 0,0),apoint<GMAP>(0, 2, 0,0),
+                             apoint<GMAP>(1, 0, 0,0),apoint<GMAP>(1, 1, 2,0));
+  dh2 = gmap.make_tetrahedron(apoint<GMAP>(0, 2, -1,0),apoint<GMAP>(-1, 0, -1,0),
+                             apoint<GMAP>(1, 0, -1,0),apoint<GMAP>(1, 1, -3,0));
+  dh3 = gmap.make_tetrahedron(apoint<GMAP>(0, 2, -4,0),apoint<GMAP>(-1, 0, -4,0),
+                             apoint<GMAP>(1, 0, -4,0),apoint<GMAP>(1, 1, -5,0));
+  gmap.template sew<3>(dh1, dh2);
+  gmap.template sew<4>(dh1, dh3);
+
+  GMAP gmap2(gmap);
+  if ( !gmap.is_valid() ) { assert(false); return false; }
+  if ( !gmap2.is_isomorphic_to(gmap) )
+  { assert(false); return false; }
+  trace_test_end();
+
+  trace_test_begin();
+  gmap.reverse_orientation();
+  if ( !gmap.is_valid() ) { assert(false); return false; }
+  if ( gmap2.is_isomorphic_to(gmap) )
+  { assert(false); return false; }
+  if ( !gmap2.is_isomorphic_to(gmap, false) )
+  { assert(false); return false; }
+  trace_test_end();
+
+  trace_test_begin();
+  gmap.reverse_orientation();
+  if ( !gmap.is_valid() ) { assert(false); return false; }
+  if ( !gmap2.is_isomorphic_to(gmap, false) )
+  { assert(false); return false; }
+  if ( !gmap2.is_isomorphic_to(gmap) )
+  { assert(false); return false; }
+  trace_test_end();
+
+  trace_test_begin();
+  gmap.reverse_orientation_connected_component(dh1);
+  if ( !gmap.is_valid() ) { assert(false); return false; }
+  if ( gmap2.is_isomorphic_to(gmap) )
+  { assert(false); return false; }
+  if ( !gmap2.is_isomorphic_to(gmap, false) )
+  { assert(false); return false; }
+  trace_test_end();
+
+  trace_test_begin();
+  gmap.reverse_orientation_connected_component(dh1);
+  if ( !gmap.is_valid() ) { assert(false); return false; }
+  if ( !gmap2.is_isomorphic_to(gmap) )
+  { assert(false); return false; }
+  trace_test_end();
+
+  //    import_from_polyhedron<GMAP>(gmap,ap);
+
+        gmap.clear();
+
+  //      import_from_plane_graph<GMAP>(gmap,ais);
+  */
+        gmap.clear();
+
+  return true;
+}
+
+#endif // CGAL_GMAP_4_TEST_H

Generalized_map/test/Generalized_map/Generalized_map_test.cpp

@@ -0,0 +1,185 @@
+#include <CGAL/Generalized_map.h>
+#include <CGAL/Cell_attribute.h>
+
+#include "Generalized_map_2_test.h"
+#include "Generalized_map_3_test.h"
+#include "Generalized_map_4_test.h"
+
+struct Sum_functor
+{
+  template<class Cell_attribute>
+  void operator()(Cell_attribute& ca1,Cell_attribute& ca2)
+  { ca1.info()=ca1.info()+ca2.info(); }
+};
+struct Divide_by_two_functor
+{
+  template<class Cell_attribute>
+  void operator()(Cell_attribute& ca1,Cell_attribute& ca2)
+  {
+    ca1.info()=(ca1.info()/2);
+    ca2.info()=(ca1.info());
+  }
+};
+
+struct Myitems_2
+{
+  template <class GMAP>
+  struct Dart_wrapper
+  {
+    typedef CGAL::GMap_dart<2, GMAP> Dart;
+
+    typedef CGAL::Cell_attribute<GMAP,int,CGAL::Tag_true,Sum_functor,
+                                 Divide_by_two_functor> myattrib;
+    typedef CGAL::cpp11::tuple<myattrib, myattrib, myattrib>
+    Attributes;
+  };
+};
+
+struct Myitems_2c
+{
+  template <class GMAP>
+  struct Dart_wrapper
+  {
+    typedef CGAL::GMap_dart<2, GMAP> Dart;
+
+    typedef CGAL::Cell_attribute<GMAP,int,CGAL::Tag_false,Sum_functor,
+                                 Divide_by_two_functor> myattrib;
+    typedef CGAL::cpp11::tuple<myattrib, myattrib, myattrib>
+    Attributes;
+  };
+};
+struct Myitems_3
+{
+  template <class GMAP>
+  struct Dart_wrapper
+  {
+    typedef CGAL::GMap_dart<3, GMAP> Dart;
+
+    typedef CGAL::Cell_attribute<GMAP,int,CGAL::Tag_true,Sum_functor,
+                                 Divide_by_two_functor> myattrib;
+    typedef CGAL::cpp11::tuple<myattrib, myattrib, myattrib, myattrib>
+    Attributes;
+  };
+};
+
+struct Myitems_3c
+{
+  template <class GMAP>
+  struct Dart_wrapper
+  {
+    typedef CGAL::GMap_dart<3, GMAP> Dart;
+
+    typedef CGAL::Cell_attribute<GMAP,int,CGAL::Tag_false,Sum_functor,
+                                 Divide_by_two_functor> myattrib;
+    typedef CGAL::cpp11::tuple<myattrib, myattrib, myattrib, myattrib>
+    Attributes;
+  };
+};
+
+struct Myitems_4
+{
+  template <class GMAP>
+  struct Dart_wrapper
+  {
+    typedef CGAL::GMap_dart<4, GMAP> Dart;
+
+    typedef CGAL::Cell_attribute<GMAP,int,CGAL::Tag_true,Sum_functor,
+                                 Divide_by_two_functor> myattrib;
+    typedef CGAL::cpp11::tuple<myattrib, myattrib, myattrib, myattrib,myattrib>
+    Attributes;
+  };
+};
+
+struct Myitems_4c
+{
+  template <class GMAP>
+  struct Dart_wrapper
+  {
+    typedef CGAL::GMap_dart<4, GMAP> Dart;
+
+    typedef CGAL::Cell_attribute<GMAP,int,CGAL::Tag_false,Sum_functor,
+                                 Divide_by_two_functor> myattrib;
+    typedef CGAL::cpp11::tuple<myattrib, myattrib, myattrib, myattrib,myattrib>
+    Attributes;
+  };
+};
+
+int main()
+{
+  std::cout<<"Generalized_map start test (v1)."<<std::flush;
+
+  trace_display_msg("\ntest_GMAP_2<GMAP2>");
+  typedef CGAL::Generalized_map<2> GMAP2;
+  if ( !test_GMAP_2<GMAP2>() )
+  {
+    std::cout<<" Error during Test_GMAP_2<GMAP2>."<<std::endl;
+    return EXIT_FAILURE;
+  }
+
+  trace_display_msg("test_GMAP_3<GMAP3>");
+  typedef CGAL::Generalized_map<3> GMAP3;
+  if ( !test_GMAP_3<GMAP3>() )
+  {
+    std::cout<<" Error during Test_GMAP_3<GMAP3>."<<std::endl;
+    return EXIT_FAILURE;
+  }
+
+  trace_display_msg("test_GMAP_4<GMAP4>");
+  typedef CGAL::Generalized_map<4> GMAP4;
+  if ( !test_GMAP_4<GMAP4>() )
+  {
+    std::cout<<" Error during Test_GMAP_4<GMAP4>."<<std::endl;
+    return EXIT_FAILURE;
+  }
+
+  trace_display_msg("test_GMAP_2<GMAP2b>");
+  typedef CGAL::Generalized_map<2,Myitems_2> GMAP2b;
+  if ( !test_GMAP_2<GMAP2b>() )
+  {
+    std::cout<<" Error during Test_GMAP_2<GMAP2b>."<<std::endl;
+    return EXIT_FAILURE;
+  }
+
+  trace_display_msg("test_GMAP_2<GMAP2c>");
+  typedef CGAL::Generalized_map<2,Myitems_2c> GMAP2c;
+  if ( !test_GMAP_2<GMAP2c>() )
+  {
+    std::cout<<" Error during Test_GMAP_2<GMAP2c>."<<std::endl;
+    return EXIT_FAILURE;
+  }
+
+  trace_display_msg("test_GMAP_3<GMAP3b>");
+  typedef CGAL::Generalized_map<3,Myitems_3> GMAP3b;
+  if ( !test_GMAP_3<GMAP3b>() )
+  {
+    std::cout<<" Error during Test_GMAP_3<GMAP3b>."<<std::endl;
+    return EXIT_FAILURE;
+  }
+
+  trace_display_msg("test_GMAP_3<GMAP3c>");
+  typedef CGAL::Generalized_map<3,Myitems_3c> GMAP3c;
+  if ( !test_GMAP_3<GMAP3c>() )
+  {
+    std::cout<<" Error during Test_GMAP_3<GMAP3c>."<<std::endl;
+    return EXIT_FAILURE;
+  }
+
+  trace_display_msg("test_GMAP_4<GMAP4b>");
+  typedef CGAL::Generalized_map<4,Myitems_4> GMAP4b;
+  if ( !test_GMAP_4<GMAP4b>() )
+  {
+    std::cout<<" Error during Test_GMAP_4<GMAP4b>."<<std::endl;
+    return EXIT_FAILURE;
+  }
+
+  trace_display_msg("test_GMAP_4<GMAP4c>");
+  typedef CGAL::Generalized_map<4,Myitems_4c> GMAP4c;
+  if ( !test_GMAP_4<GMAP4c>() )
+  {
+    std::cout<<" Error during Test_GMAP_4<GMAP4c>."<<std::endl;
+    return EXIT_FAILURE;
+  }
+
+  std::cout<<" Success."<<std::endl;
+  return EXIT_SUCCESS;
+}

Generalized_map/test/Generalized_map/data/aircraft.off

@@ -0,0 +1,317 @@
+OFF
+154 161 313
+-0.000357203 -0.235365 -0.160125
+-0.000357203 -0.201317 -0.488359
+-0.000357203 -0.292821 0.0217439
+0.190729 -0.13758 0.378379
+0.13019 -0.267236 0.298845
+0.190729 0.0100846 0.378379
+0.0215368 0.217461 -0.51172
+0.0299628 0.207248 -0.0999594
+0.0292682 0.222545 -0.275104
+0.0768803 0.121009 -0.13791
+0.0359848 0.17055 -0.040928
+0.0299468 -0.152925 -0.34216
+0.025316 0.0079986 -0.671613
+0.112137 0.0486489 -0.334468
+0.17708 0.0141305 -0.001149
+0.11094 0.149864 0.298845
+0.0221919 -0.110187 -0.590456
+0.0936803 -0.22453 0.026899
+0.113404 -0.0498528 -0.316654
+0.0652844 0.112329 -0.345801
+0.17708 -0.120885 0.017739
+0.0936803 0.144433 -0.0331753
+-0.000357203 -0.335018 0.298845
+-0.000357203 0.158995 -0.742002
+-0.000357203 0.00799863 -0.742002
+-0.000357203 0.231668 -0.508839
+-0.000357203 -0.150077 -0.732558
+-0.000357203 0.183546 0.298845
+-0.000357203 0.232012 -0.275104
+0.190729 0.0489168 0.495135
+0.11094 0.149864 0.495135
+0.13019 -0.267236 0.495135
+0.190729 -0.0987481 0.495135
+0.165251 0.0336246 0.567519
+0.0961008 0.121112 0.567519
+-0.000357203 0.150303 0.567519
+-0.000357203 -0.299119 0.567519
+0.112784 -0.240374 0.567519
+0.165251 -0.0943517 0.567519
+0.158169 0.0203713 0.567519
+0.0832397 0.0961934 0.567519
+-0.000357203 0.121493 0.567519
+-0.000357203 -0.268007 0.567519
+0.0976983 -0.217095 0.567519
+0.158169 -0.0905415 0.567519
+0.158169 0.0203713 0.484629
+0.0832397 0.0961934 0.484629
+-0.000357203 0.121493 0.484629
+0.0976983 -0.217095 0.484629
+0.158169 -0.0905415 0.484629
+0.232021 -0.0969884 0.147736
+0.222564 -0.0120031 0.135774
+0.241484 -0.0124758 0.32577
+0.251828 -0.105423 0.32577
+0.221675 -0.0537317 -0.14475
+0.547234 0.011391 0.135774
+0.566079 0.0115894 0.32577
+0.573698 -0.0568671 0.32577
+0.545139 -0.0195028 -0.0723815
+0.5542 -0.0512014 0.147736
+0.873235 0.0322361 0.18891
+0.883911 0.0323485 0.29654
+0.888226 -0.00643099 0.29654
+0.872049 0.0147353 0.0957062
+0.877181 -0.00322145 0.195687
+0.956323 0.0235341 0.192298
+0.963222 0.0286616 0.264585
+0.143323 0.0162689 -0.433251
+0.0684487 0.00718598 -0.642478
+0.142247 0.0417387 -0.448393
+0.379652 0.0694599 -0.566806
+0.37455 0.0944136 -0.566806
+0.405166 0.0746761 -0.587722
+0.343995 0.0918102 -0.908647
+0.400064 0.0996298 -0.587722
+0.420699 -0.131311 -0.566806
+0.39516 -0.100331 -0.908647
+0.446883 -0.129375 -0.587722
+0.3308 0.214471 -0.908647
+0.344344 0.242162 -0.566806
+0.369364 0.249793 -0.587722
+0.349639 0.09078 -0.834104
+-0.0943947 0.144433 -0.0331752
+-0.177794 0.0141305 -0.001149
+-0.112851 0.0486489 -0.334468
+-0.0659988 0.112329 -0.345801
+-0.0775947 0.121009 -0.13791
+-0.0260305 0.0079986 -0.671613
+-0.0222512 0.217461 -0.51172
+-0.0943947 -0.22453 0.026899
+-0.130905 -0.267236 0.298845
+-0.000357203 0.173965 -0.0160962
+-0.111655 0.149864 0.298845
+-0.0366992 0.17055 -0.040928
+-0.0306611 -0.152925 -0.34216
+-0.114118 -0.0498528 -0.316654
+-0.177794 -0.120885 0.0177391
+-0.0299827 0.222544 -0.275104
+-0.0229063 -0.110187 -0.590456
+-0.0306772 0.207248 -0.0999594
+-0.000357203 0.216146 -0.0919062
+-0.191443 0.0100846 0.378379
+-0.191443 -0.13758 0.378379
+-0.87395 0.0322361 0.18891
+-0.957037 0.0235341 0.192298
+-0.884625 0.0323485 0.29654
+-0.963936 0.0286615 0.264585
+-0.346372 0.0918103 -0.905359
+-0.40588 0.0746761 -0.587722
+-0.400779 0.0996299 -0.602235
+-0.222389 -0.0537316 -0.14475
+-0.111655 0.149864 0.495135
+-0.191443 0.0489168 0.495135
+-0.000357203 0.183546 0.495135
+-0.130905 -0.267236 0.495135
+-0.000357203 -0.335018 0.495135
+-0.191443 -0.0987481 0.495135
+-0.0968152 0.121112 0.567519
+-0.165965 0.0336246 0.567519
+-0.113498 -0.240374 0.567519
+-0.165965 -0.0943517 0.567519
+-0.0839541 0.0961934 0.567519
+-0.143884 0.0203713 0.567519
+-0.0984127 -0.217095 0.567519
+-0.143884 -0.0905415 0.567519
+-0.0839541 0.0961934 0.484629
+-0.143884 0.0203713 0.484629
+-0.0984127 -0.217095 0.484629
+-0.000357203 -0.268007 0.484629
+-0.143884 -0.0905415 0.484629
+-0.223278 -0.0120031 0.135774
+-0.242198 -0.0124758 0.32577
+-0.252542 -0.105423 0.32577
+-0.232736 -0.0969883 0.147736
+-0.872763 0.0147353 0.0957062
+-0.566794 0.0115894 0.32577
+-0.547948 0.011391 0.135774
+-0.574412 -0.0568671 0.32577
+-0.554914 -0.0512014 0.147736
+-0.545854 -0.0195028 -0.0723815
+-0.888941 -0.00643099 0.29654
+-0.877895 -0.00322148 0.195687
+-0.069163 0.00718598 -0.642478
+-0.144038 0.0162689 -0.433251
+-0.142961 0.0417387 -0.448393
+-0.375265 0.0944137 -0.58132
+-0.350353 0.0907801 -0.834105
+-0.380366 0.0694599 -0.566806
+-0.421413 -0.131311 -0.658428
+-0.397537 -0.100331 -0.882239
+-0.447598 -0.129375 -0.691307
+-0.333177 0.214471 -0.877766
+-0.345058 0.242162 -0.663246
+-0.370078 0.249793 -0.695961
+5   14 13 19 9 21
+3   24 6 19
+4   2 17 4 22
+5   27 15 21 10 91
+4   18 20 17 11
+4   18 11 24 12
+3   6 24 23
+4   28 8 6 25
+3   25 6 23
+3   16 1 26
+4   17 2 0 11
+4   11 0 1 16
+3   10 21 9
+3   8 19 6
+4   7 100 91 10
+3   7 10 9
+4   21 15 5 14
+4   20 3 4 17
+4   60 61 66 65
+3   73 74 72
+5   14 54 20 18 13
+4   15 30 29 5
+4   27 113 30 15
+4   4 31 115 22
+4   3 32 31 4
+4   5 29 32 3
+4   30 34 33 29
+4   113 35 34 30
+4   31 37 36 115
+4   32 38 37 31
+4   29 33 38 32
+4   34 40 39 33
+4   35 41 40 34
+4   37 43 42 36
+4   38 44 43 37
+4   33 39 44 38
+4   40 46 45 39
+4   41 47 46 40
+4   43 48 128 42
+4   44 49 48 43
+4   39 45 49 44
+4   7 8 28 100
+4   7 9 19 8
+3   14 51 54
+4   5 52 51 14
+4   3 53 52 5
+4   20 50 53 3
+3   50 20 54
+3   60 65 63
+4   52 56 55 51
+4   53 57 56 52
+4   50 59 57 53
+4   51 55 58 54
+4   54 58 59 50
+4   56 61 60 55
+4   57 62 61 56
+4   59 64 62 57
+4   55 60 63 58
+4   58 63 64 59
+4   66 62 64 65
+3   65 64 63
+3   66 61 62
+4   12 68 67 18
+4   13 69 68 12
+4   18 67 69 13
+4   69 71 81 68
+4   67 70 71 69
+3   76 77 75
+3   79 80 78
+4   70 72 74 71
+5   73 76 75 70 81
+4   72 77 76 73
+4   70 75 77 72
+5   71 79 78 73 81
+4   74 80 79 71
+4   73 78 80 74
+4   81 70 67 68
+5   86 85 84 83 82
+4   24 87 84 85
+4   90 89 2 22
+5   93 82 92 27 91
+4   89 96 95 94
+3   94 95 87
+4   88 97 28 25
+3   88 25 23
+3   1 98 26
+4   0 2 89 94
+4   1 0 94 98
+4   24 98 94 87
+3   82 93 86
+3   85 97 88
+4   91 100 99 93
+3   93 99 86
+4   101 92 82 83
+4   90 102 96 89
+4   106 105 103 104
+3   26 98 24
+3   109 107 108
+5   95 96 110 83 84
+4   112 111 92 101
+4   111 113 27 92
+4   115 114 90 22
+4   114 116 102 90
+4   116 112 101 102
+4   118 117 111 112
+4   117 35 113 111
+4   36 119 114 115
+4   119 120 116 114
+4   120 118 112 116
+4   122 121 117 118
+4   121 41 35 117
+4   42 123 119 36
+4   123 124 120 119
+4   124 122 118 120
+4   126 125 121 122
+4   125 47 41 121
+4   128 127 123 42
+4   127 129 124 123
+4   129 126 122 124
+4   28 97 99 100
+4   85 86 99 97
+3   130 83 110
+4   130 131 101 83
+4   131 132 102 101
+4   132 133 96 102
+3   96 133 110
+3   104 103 134
+4   136 135 131 130
+4   135 137 132 131
+4   137 138 133 132
+4   139 136 130 110
+4   138 139 110 133
+4   103 105 135 136
+4   105 140 137 135
+4   140 141 138 137
+4   134 103 136 139
+4   141 134 139 138
+4   141 140 106 104
+3   141 104 134
+3   105 106 140
+4   143 142 87 95
+4   142 144 84 87
+4   144 143 95 84
+4   146 145 144 142
+4   145 147 143 144
+3   150 149 148
+3   153 152 151
+4   109 108 147 145
+5   147 148 149 107 146
+4   149 150 108 107
+4   150 148 147 108
+5   107 151 152 145 146
+4   152 153 109 145
+4   153 151 107 109
+4   143 147 146 142
+10   128 48 49 45 46 47 125 126 129 127
+3   88 23 24
+4   19 13 12 24
+3   16 26 24
+3   11 16 24
+3   85 88 24

Generalized_map/test/Generalized_map/data/small_points

@@ -0,0 +1,6 @@
+0 0 0
+1 0 0
+0 1 0
+0 0 1
+2 2 2
+-1 0 1

Generalized_map/test/Generalized_map/data/small_points2

@@ -0,0 +1,5 @@
+0 0 0
+1 0 0
+0 1 0
+0 0 1
+2 2 2