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

Update LCC to be compatible both for CMap and GMap.

This commit is contained in:
Guillaume Damiand 2016-10-20 12:47:36 -04:00
parent 8d577b35da
commit 8d22d7e7dc
10 changed files with 125 additions and 870 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Linear_cell_complex/demo/Linear_cell_complex/CMakeLists.txt
View File

@ -64,6 +64,7 @@ add_executable(Linear_cell_complex_3_demo
Linear_cell_complex_3_demo.cpp MainWindow.cpp
Viewer.cpp Linear_cell_complex_3_subdivision.cpp
Linear_cell_complex_pqq_subdivision.cpp
typedefs.h import_moka.h
${uis} ${CGAL_Qt5_RESOURCE_FILES} ${CGAL_Qt5_MOC_FILES})
qt5_use_modules(Linear_cell_complex_3_demo Xml Script OpenGL Svg)

11
Linear_cell_complex/demo/Linear_cell_complex/Viewer.cpp
View File

@ -324,6 +324,7 @@ void Viewer::compute_face(Dart_handle dh, LCC::size_type markface)
he_circ_end = lcc.darts_of_orbit<1>(dh).end();
he_circ!=he_circ_end; ++he_circ)
{
std::cout<<lcc.point(he_circ)<<std::endl;
CDT::Vertex_handle vh = cdt.insert(lcc.point(he_circ));
if(first == NULL)
{ first = vh; }
@ -639,11 +640,11 @@ void Viewer::sceneChanged()
{
compute_elements();
this->camera()->setSceneBoundingBox(qglviewer::Vec(bb.xmin(),
bb.ymin(),
bb.zmin()),
qglviewer::Vec(bb.xmax(),
bb.ymax(),
bb.zmax()));
bb.ymin(),
bb.zmin()),
qglviewer::Vec(bb.xmax(),
bb.ymax(),
bb.zmax()));
are_buffers_initialized = false;
if (m_previous_scene_empty)

2
Linear_cell_complex/demo/Linear_cell_complex/typedefs.h
View File

@ -185,7 +185,7 @@ struct Face_info {
bool is_process;
};
typedef CGAL::Triangulation_2_projection_traits_3<Mytraits> P_traits;
typedef CGAL::Triangulation_2_projection_traits_3<CGAL::Exact_predicates_inexact_constructions_kernel> P_traits;
typedef CGAL::Triangulation_vertex_base_with_info_2<Vertex_info, P_traits> Vb;
typedef CGAL::Triangulation_face_base_with_info_2<Face_info,P_traits> Fb1;

37
Linear_cell_complex/include/CGAL/CMap_linear_cell_complex_storages.h
View File

@ -17,10 +17,13 @@
//
// Author(s) : Guillaume Damiand <guillaume.damiand@liris.cnrs.fr>
//
#ifndef CGAL_LINEAR_CELL_COMPLEX_STORAGES_H
#define CGAL_LINEAR_CELL_COMPLEX_STORAGES_H 1
#ifndef CGAL_CMAP_LINEAR_CELL_COMPLEX_STORAGES_H
#define CGAL_CMAP_LINEAR_CELL_COMPLEX_STORAGES_H 1
#include <CGAL/Combinatorial_map_storages.h>
#include <CGAL/Handle_hash_function.h>
#include <CGAL/Compact_container.h>
#include <CGAL/Dart.h>
#include <bitset>
#include <boost/config.hpp>
#if (BOOST_GCC >= 40900)
@ -30,8 +33,13 @@ _Pragma("GCC diagnostic ignored \"-Warray-bounds\"")
namespace CGAL {
/** @file Linear_cell_complex_storages.h
* Definition of storages for dD Linear cell complex.
namespace internal {
template <typename M>
struct Combinatorial_map_helper;
}
/** @file CMap_linear_cell_complex_storages.h
* Definition of storages for dD Linear cell complex for combinatorial maps.
*/
// Storage of darts with compact container, beta with handles
@ -41,14 +49,14 @@ namespace CGAL {
// the correct type).
template<unsigned int d_, unsigned int ambient_dim,
class Traits_, class Items_, class Alloc_ >
class Linear_cell_complex_storage_1
class CMap_linear_cell_complex_storage_1
{
public:
typedef typename Traits_::Point Point;
typedef typename Traits_::Vector Vector;
typedef typename Traits_::FT FT;
typedef Linear_cell_complex_storage_1<d_, ambient_dim, Traits_,
typedef CMap_linear_cell_complex_storage_1<d_, ambient_dim, Traits_,
Items_, Alloc_> Self;
typedef CGAL::Tag_false Use_index;
@ -315,9 +323,9 @@ namespace CGAL {
#if !defined(CGAL_CMAP_DART_DEPRECATED) || defined(CGAL_NO_DEPRECATED_CODE)
// Get the information associated with a given dart
typename Dart::Info& info(Dart_handle adart)
Dart_info& info(Dart_handle adart)
{ return adart->info(); }
const typename Dart::Info& info(Dart_const_handle adart) const
const Dart_info& info(Dart_const_handle adart) const
{ return adart->info(); }
#endif
@ -458,15 +466,16 @@ namespace CGAL {
/// null_handle
template<unsigned int d_, unsigned int ambient_dim,
class Traits_, class Items_, class Alloc_ >
const typename Linear_cell_complex_storage_1<d_, ambient_dim, Traits_,
Items_, Alloc_>::Null_handle_type
Linear_cell_complex_storage_1<d_, ambient_dim, Traits_, Items_, Alloc_>::
null_handle = NULL;
const typename CMap_linear_cell_complex_storage_1<d_, ambient_dim, Traits_,
Items_, Alloc_>::Null_handle_type
CMap_linear_cell_complex_storage_1<d_, ambient_dim, Traits_,
Items_, Alloc_>::null_handle = NULL;
} // namespace CGAL
#if (BOOST_GCC >= 40900)
_Pragma("GCC diagnostic pop")
#endif
#endif // CGAL_LINEAR_CELL_COMPLEX_STORAGES_H //
#endif // CGAL_CMAP_LINEAR_CELL_COMPLEX_STORAGES_H //
// EOF //

6
Linear_cell_complex/include/CGAL/Cell_attribute_with_point.h
View File

@ -63,9 +63,6 @@ namespace CGAL {
Functor_on_merge_, Functor_on_split_>,
public Point_for_cell<typename LCC::Point>
{
/* template < unsigned int, class, class, class, class >
friend class Combinatorial_map_base;
*/
template <class, class, class, class>
friend class Compact_container;
@ -118,9 +115,6 @@ namespace CGAL {
public Cell_attribute<LCC, void, Tag, Functor_on_merge_, Functor_on_split_>,
public Point_for_cell<typename LCC::Point>
{
/* template < unsigned int, class, class, class, class >
friend class Combinatorial_map_base;
*/
template <class, class, class, class>
friend class Compact_container;

14
Linear_cell_complex/include/CGAL/GMap_linear_cell_complex_storages.h
View File

@ -20,7 +20,10 @@
#ifndef CGAL_GMAP_LINEAR_CELL_COMPLEX_STORAGES_H
#define CGAL_GMAP_LINEAR_CELL_COMPLEX_STORAGES_H 1
#include <CGAL/Generalized_map_storages.h>
#include <CGAL/Handle_hash_function.h>
#include <CGAL/Compact_container.h>
#include <CGAL/Dart.h>
#include <bitset>
#include <boost/config.hpp>
#if (BOOST_GCC >= 40900)
@ -30,6 +33,11 @@ _Pragma("GCC diagnostic ignored \"-Warray-bounds\"")
namespace CGAL {
namespace internal {
template <typename M>
struct Combinatorial_map_helper;
}
/** @file GMap_linear_cell_complex_storages.h
* Definition of storages for dD Linear cell complex for generalized map.
*/
@ -308,9 +316,9 @@ namespace CGAL {
}
// Get the information associated with a given dart
typename Dart::Info& info(Dart_handle adart)
Dart_info& info(Dart_handle adart)
{ return adart->info(); }
const typename Dart::Info& info(Dart_const_handle adart) const
const Dart_info& info(Dart_const_handle adart) const
{ return adart->info(); }
// Get the info of the given attribute

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

@ -40,9 +40,9 @@ namespace CGAL {
class Alloc_ = CGAL_ALLOCATOR(int),
template<unsigned int,class,class,class,class>
class CMap = Combinatorial_map_base,
class Storage_ = Linear_cell_complex_storage_1<d_, ambient_dim,
Traits_, Items_,
Alloc_> >
class Storage_ = CMap_linear_cell_complex_storage_1<d_, ambient_dim,
Traits_, Items_,
Alloc_> >
class CGAL_DEPRECATED Linear_cell_complex:
public Linear_cell_complex_for_combinatorial_map<d_, ambient_dim, Traits_, Items_,
Alloc_, CMap, Storage_>

811
Linear_cell_complex/include/CGAL/Linear_cell_complex_for_combinatorial_map.h
View File

@ -20,778 +20,20 @@
#ifndef CGAL_LINEAR_CELL_COMPLEX_FOR_COMBINATORIAL_MAP_H
#define CGAL_LINEAR_CELL_COMPLEX_FOR_COMBINATORIAL_MAP_H 1
#include <CGAL/Combinatorial_map.h>
#include <CGAL/Combinatorial_map_constructors.h>
#include <CGAL/Linear_cell_complex_operations.h>
#include <CGAL/Linear_cell_complex_min_items.h>
#include <CGAL/Linear_cell_complex_base.h>
#include <CGAL/Linear_cell_complex_traits.h>
#include <CGAL/Linear_cell_complex_storages.h>
#include <CGAL/Linear_cell_complex_min_items.h>
#include <CGAL/Combinatorial_map.h>
#include <CGAL/CMap_linear_cell_complex_storages.h>
namespace CGAL {
/** @file Linear_cell_complex_for_combinatorial_map.h
* Definition of a linear cell complex, i.e. a combinatorial map with points
* associated to all vertices.
* Definition of a linear cell complex based on combinatorial map, having
* points associated to all vertices.
*/
/** Linear_cell_complex_base class.
* The Linear_cell_complex a nD object with linear geometry, ie
* an nD combinatorial map with point associated to each vertex.
*/
template < unsigned int d_, unsigned int ambient_dim,
class Traits_,
class Items_,
class Alloc_,
template<unsigned int,class,class,class,class>
class CMap,
class Refs,
class Storage_>
class Linear_cell_complex_base:
public CMap<d_, Refs, Items_, Alloc_, Storage_>
{
public:
typedef Linear_cell_complex_base<d_, ambient_dim,
Traits_, Items_, Alloc_, CMap,
Refs, Storage_> Self;
typedef CMap<d_, Refs, Items_, Alloc_, Storage_> Base;
typedef Traits_ Traits;
typedef Items_ Items;
typedef Alloc_ Alloc;
typedef Storage_ Storage;
static const unsigned int ambient_dimension = ambient_dim;
static const unsigned int dimension = Base::dimension;
typedef typename Storage::Dart_handle Dart_handle;
typedef typename Storage::Dart_const_handle Dart_const_handle;
typedef typename Storage::Helper Helper;
typedef typename Storage::Point Point;
typedef typename Storage::Vector Vector;
typedef typename Storage::FT FT;
typedef typename Base::Dart_range Dart_range;
/// Typedef for attributes
template<int i>
struct Attribute_type: public Base::template Attribute_type<i>
{};
template<int i>
struct Attribute_handle: public Base::template Attribute_handle<i>
{};
template<int i>
struct Attribute_const_handle:
public Base::template Attribute_const_handle<i>
{};
template<int i>
struct Attribute_range: public Base::template Attribute_range<i>
{};
template<int i>
struct Attribute_const_range:
public Base::template Attribute_const_range<i>
{};
typedef typename Base::template Attribute_type<0>::type Vertex_attribute;
typedef typename Base::template Attribute_handle<0>::type
Vertex_attribute_handle;
typedef typename Base::template Attribute_const_handle<0>::type
Vertex_attribute_const_handle;
typedef typename Base::template Attribute_range<0>::type
Vertex_attribute_range;
typedef typename Base::template Attribute_const_range<0>::type
Vertex_attribute_const_range;
typedef typename Base::size_type size_type;
typedef typename Base::Use_index Use_index;
typedef typename Base::Exception_no_more_available_mark
Exception_no_more_available_mark;
/// To use previous definition of create_dart methods.
using Base::create_dart;
using Base::attribute;
using Base::null_handle;
using Base::point_of_vertex_attribute;
using Base::are_attributes_automatically_managed;
using Base::mark;
using Base::unmark;
using Base::free_mark;
using Base::get_new_mark;
using Base::make_segment;
using Base::make_triangle;
using Base::make_quadrangle;
using Base::insert_cell_0_in_cell_1;
using Base::insert_cell_0_in_cell_2;
using Base::insert_dangling_cell_1_in_cell_2;
using Base::insert_cell_1_in_cell_2;
using Base::insert_cell_2_in_cell_3;
Linear_cell_complex_base() : Base()
{}
/** Copy the given linear cell complex into *this.
* Note that both LCC can have different dimensions and/or non void attributes.
* @param alcc the linear cell complex to copy.
* @post *this is valid.
*/
Linear_cell_complex_base(const Self& alcc) : Base()
{ Base::copy/*<Self>*/(alcc); }
template < class LCC2 >
Linear_cell_complex_base(const LCC2& alcc) : Base()
{ Base::copy/*<LCC2>*/(alcc);}
template < class LCC2, typename Converters >
Linear_cell_complex_base(const LCC2& alcc, Converters& converters) : Base()
{ Base::copy/*<LCC2, Converters>*/(alcc, converters);}
template < class LCC2, typename Converters, typename DartInfoConverter >
Linear_cell_complex_base(const LCC2& alcc, Converters& converters,
const DartInfoConverter& dartinfoconverter) : Base()
{ Base::copy// TODO REMOVEtemplate copy<LCC2, Converters, Pointconverter>
(alcc, converters, dartinfoconverter);}
template < class LCC2, typename Converters, typename DartInfoConverter,
typename Pointconverter >
Linear_cell_complex_base(const LCC2& alcc, Converters& converters,
const DartInfoConverter& dartinfoconverter,
const Pointconverter& pointconverter) : Base()
{ Base::copy//template copy<LCC2, Converters, Pointconverter>
(alcc, converters, dartinfoconverter, pointconverter);}
/** Affectation operation. Copies one map to the other.
* @param amap a lcc.
* @return A copy of that lcc.
*/
Self & operator= (const Self & alcc)
{
if (this!=&alcc)
{
Self tmp(alcc);
this->swap(tmp);
}
return *this;
}
/** Create a vertex attribute.
* @return an handle on the new attribute.
*/
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
template<typename ...Args>
Vertex_attribute_handle create_vertex_attribute(const Args&... args)
{ return Base::template create_attribute<0>(args...); }
#else
Vertex_attribute_handle create_vertex_attribute()
{ return Base::template create_attribute<0>(); }
template<typename T1>
Vertex_attribute_handle create_vertex_attribute(const T1& t1)
{ return Base::template create_attribute<0>(t1); }
template<typename T1, typename T2>
Vertex_attribute_handle create_vertex_attribute
(const T1& t1, const T2 &t2)
{ return Base::template create_attribute<0>(t1, t2); }
template<typename T1, typename T2, typename T3>
Vertex_attribute_handle create_vertex_attribute
(const T1& t1, const T2 &t2, const T3 &t3)
{ return Base::template create_attribute<0>(t1, t2, t3); }
template<typename T1, typename T2, typename T3, typename T4>
Vertex_attribute_handle create_vertex_attribute
(const T1& t1, const T2 &t2, const T3 &t3, const T4 &t4)
{ return Base::template create_attribute<0>(t1, t2, t3, t4); }
template<typename T1, typename T2, typename T3, typename T4, typename T5>
Vertex_attribute_handle create_vertex_attribute
(const T1& t1, const T2 &t2, const T3 &t3, const T4 &t4,
const T5 &t5)
{ return Base::template create_attribute<0>(t1, t2, t3, t4, t5); }
template<typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6>
Vertex_attribute_handle create_vertex_attribute
(const T1& t1, const T2 &t2, const T3 &t3, const T4 &t4,
const T5 &t5, const T6 &t6)
{ return Base::template create_attribute<0>(t1, t2, t3, t4, t5, t6); }
template<typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7>
Vertex_attribute_handle create_vertex_attribute
(const T1& t1, const T2 &t2, const T3 &t3, const T4 &t4,
const T5 &t5, const T6 &t6, const T7 &t7)
{ return Base::template create_attribute<0>(t1, t2, t3, t4, t5, t6, t7); }
template<typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8>
Vertex_attribute_handle create_vertex_attribute
(const T1& t1, const T2 &t2, const T3 &t3, const T4 &t4,
const T5 &t5, const T6 &t6, const T7 &t7, const T8 &t8)
{ return Base::template create_attribute<0>(t1, t2, t3, t4, t5, t6, t7,
t8); }
template<typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9>
Vertex_attribute_handle create_vertex_attribute
(const T1& t1, const T2 &t2, const T3 &t3, const T4 &t4,
const T5 &t5, const T6 &t6, const T7 &t7, const T8 &t8, const T9 &t9)
{ return Base::template create_attribute<0>(t1, t2, t3, t4, t5, t6, t7,
t8, t9); }
#endif // CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
/**
* Create a new dart associated with an handle through an attribute.
* @param ahandle the point handle to associated with the dart.
* @return a Dart_handle on the new dart.
*/
Dart_handle create_dart(Vertex_attribute_handle ahandle)
{
Dart_handle res = create_dart();
set_vertex_attribute_of_dart(res,ahandle);
return res;
}
/** Create a new dart associated with a point.
* @param apoint the point to associated with the dart.
* @return a Dart_handle on the new dart.
*/
Dart_handle create_dart(const Point& apoint)
{ return create_dart(create_vertex_attribute(apoint)); }
/** Erase a given vertex attribute.
* @param ahandle the handle to the vertex attribute to erase.
*/
void erase_vertex_attribute(Vertex_attribute_handle ahandle)
{ Base::template erase_attribute<0>(ahandle); }
/** Set the vertex attribute of the given dart.
* @param adart a dart.
* @param ah the attribute to set.
*/
void set_vertex_attribute_of_dart(Dart_handle adart,
Vertex_attribute_handle ah)
{
return CGAL::internal::Set_i_attribute_of_dart_functor<Self, 0>::
run(*this, adart, ah);
}
/** Set the vertex attribute of all the darts of the vertex.
* @param adart a dart of the vertex.
* @param ah the attribute to set.
*/
void set_vertex_attribute(Dart_handle adart,
Vertex_attribute_handle ah)
{ return CGAL::Set_i_attribute_functor<Self, 0>::run(*this, adart, ah); }
/// @return the Vertex_attribute_range for all vertex_attributes.
Vertex_attribute_range& vertex_attributes()
{ return this->template attributes<0>(); }
/// @return the Vertex_attribute_const_range for all vertex_attributes.
Vertex_attribute_const_range& vertex_attributes() const
{ return this->template attributes<0>(); }
/// @return the size of the vertex_attribute container.
typename Base::size_type number_of_vertex_attributes() const
{ return Base::template number_of_attributes<0>(); }
/// Get the vertex_attribute associated with a dart.
/// @param a dart
/// @return the vertex_attribute.
Vertex_attribute_handle vertex_attribute(Dart_handle adart)
{ return this->template attribute<0>(adart); }
/// Get the vertex_attribute associated with a const dart.
/// @param a dart
/// @return the vertex_const_attribute.
Vertex_attribute_const_handle
vertex_attribute(Dart_const_handle adart) const
{ return this->template attribute<0>(adart); }
/// Get the point associated with a dart.
/// @param a dart
/// @return the point.
Point& point(Dart_handle adart)
{
CGAL_assertion(this->template attribute<0>(adart)!=null_handle );
return point_of_vertex_attribute(this->template attribute<0>(adart));
}
/// Get the point associated with a const dart.
/// @param a dart
/// @return the point.
const Point& point(Dart_const_handle adart) const
{
CGAL_assertion(this->template attribute<0>(adart)!=null_handle );
return point_of_vertex_attribute(this->template attribute<0>(adart));
}
/** Test if the lcc is valid.
* A Linear_cell_complex is valid if it is a valid Combinatorial_map with
* an attribute associated to each dart.
* @return true iff the map is valid.
*/
bool is_valid() const
{
bool valid = Base::is_valid();
for (typename Dart_range::const_iterator it(this->darts().begin()),
itend(this->darts().end()); valid && it != itend; ++it)
{
if ( vertex_attribute(it)==null_handle )
{
std::cerr << "Map not valid: dart "<<&(*it)
<<" does not have a vertex."<< std::endl;
valid = false;
}
}
return valid;
}
/** validate the lcc
*/
void correct_invalid_attributes()
{
// Copy of the code in CMap::correct_invalid_attributes() to avoid
// 2 iterations through the darts of the map.
std::vector<size_type> marks(dimension+1);
for ( unsigned int i=0; i<=dimension; ++i)
marks[i] = Base::INVALID_MARK;
Helper::template
Foreach_enabled_attributes<Reserve_mark_functor<Self> >::
run(*this, marks);
for ( typename Dart_range::iterator it(this->darts().begin()),
itend(this->darts().end()); it!=itend; ++it)
{
Helper::template Foreach_enabled_attributes
<internal::Correct_invalid_attributes_functor<Self> >::
run(*this, it, marks);
if ( vertex_attribute(it)==null_handle )
{
// If a dart don't have a 0-attribute, we create a Point at the origin
set_vertex_attribute(it, create_vertex_attribute(CGAL::ORIGIN));
}
}
for ( unsigned int i=0; i<=dimension; ++i)
if ( marks[i]!=Base::INVALID_MARK )
{
CGAL_assertion( this->is_whole_map_marked(marks[i]) );
free_mark(marks[i]);
}
Helper::template
Foreach_enabled_attributes<internal::Cleanup_useless_attributes<Self> >::
run(*this);
}
/** test if the two given facets have the same geometry
* @return true iff the two facets have the same geometry.
*/
bool are_facets_same_geometry(Dart_const_handle d1,
Dart_const_handle d2) const
{
typename Base::template Dart_of_orbit_range<1>::const_iterator
it1(*this,d1);
typename Base::template Dart_of_orbit_range<0>::const_iterator
it2(*this,d2);
bool samegeometry = true;
for ( ; samegeometry && it1.cont() && it2.cont(); ++it1, ++it2)
{
if ( this->other_extremity(it2)!=null_handle &&
point(it1)!=point(this->other_extremity(it2)) )
samegeometry = false;
}
if ( it1.cont() != it2.cont() ) samegeometry = false;
return samegeometry;
}
/// Sew3 the marked facets having same geometry
/// (a facet is considered marked if one of its dart is marked).
unsigned int sew3_same_facets(size_type AMark)
{
unsigned int res = 0;
std::map<Point, std::vector<Dart_handle> > one_dart_per_facet;
size_type mymark = get_new_mark();
// First we fill the std::map by one dart per facet, and by using
// the minimal point as index.
for (typename Dart_range::iterator it(this->darts().begin()),
itend(this->darts().end()); it!=itend; ++it )
{
if ( !this->is_marked(it, mymark) && this->is_marked(it, AMark) )
{
Point min_point=point(it);
Dart_handle min_dart = it;
this->mark(it, mymark);
typename Base::template
Dart_of_orbit_range<1>::iterator it2(*this,it);
++it2;
for ( ; it2.cont(); ++it2 )
{
Point cur_point=point(it2);
this->mark(it2, mymark);
if ( cur_point < min_point )
{
min_point = cur_point;
min_dart = it2;
}
}
one_dart_per_facet[min_point].push_back(min_dart);
}
else
this->mark(it, mymark);
}
// Second we run through the map: candidates for sew3 have necessary the
// same minimal point.
typename std::map<Point, std::vector<Dart_handle> >::iterator
itmap=one_dart_per_facet.begin(),
itmapend=one_dart_per_facet.end();
for ( ; itmap!=itmapend; ++itmap )
{
for ( typename std::vector<Dart_handle>::iterator
it1=(itmap->second).begin(),
it1end=(itmap->second).end(); it1!=it1end; ++it1 )
{
typename std::vector<Dart_handle>::iterator it2=it1;
for ( ++it2; it2!= it1end; ++it2 )
{
if ( *it1!=*it2 &&
!this->template is_opposite_exist<3>(*it1) &&
!this->template is_opposite_exist<3>(*it2) &&
are_facets_same_geometry(*it1,this->beta(*it2, 0)) )
{
++res;
this->template sew<3>(*it1,this->beta(*it2, 0));
}
}
}
}
CGAL_assertion( this->is_whole_map_marked(mymark) );
this->free_mark(mymark);
return res;
}
/// Sew3 the facets having same geometry
/// (all the facets of the map are considered)
unsigned int sew3_same_facets()
{
size_type mark = this->get_new_mark();
this->negate_mark(mark);
unsigned int res=sew3_same_facets(mark);
this->free_mark(mark);
return res;
}
/** Create a segment given 2 points.
* @param p0 the first point.
* @param p1 the second point.
* @return the dart of the new segment incident to p0.
*/
Dart_handle make_segment(const Point& p0,const Point& p1)
{
return make_segment(create_vertex_attribute(p0),
create_vertex_attribute(p1));
}
/** Create a triangle given 3 points.
* @param p0 the first point.
* @param p1 the second point.
* @param p2 the third point.
* @return the dart of the new triangle incident to p0 and edge p0p1.
*/
Dart_handle make_triangle(const Point& p0,
const Point& p1,
const Point& p2)
{
return make_triangle(create_vertex_attribute(p0),
create_vertex_attribute(p1),
create_vertex_attribute(p2));
}
/** Create a quadrangle given 4 points.
* @param p0 the first point.
* @param p1 the second point.
* @param p2 the third point.
* @param p3 the fourth point.
* @return the dart of the new quadrangle incident to p0 and edge p0p1.
*/
Dart_handle make_quadrangle(const Point& p0,
const Point& p1,
const Point& p2,
const Point& p3)
{
return make_quadrangle(create_vertex_attribute(p0),
create_vertex_attribute(p1),
create_vertex_attribute(p2),
create_vertex_attribute(p3));
}
/** Create a tetrahedron given 4 Vertex_attribute_handle.
* @param h0 the first vertex handle.
* @param h1 the second vertex handle.
* @param h2 the third vertex handle.
* @param h3 the fourth vertex handle.
* @return the dart of the new tetrahedron incident to h0, to edge
* h0,h1 and to facet h0,h1,h2.
*/
Dart_handle make_tetrahedron(Vertex_attribute_handle h0,
Vertex_attribute_handle h1,
Vertex_attribute_handle h2,
Vertex_attribute_handle h3)
{
Dart_handle d1 = make_triangle(h0, h1, h2);
Dart_handle d2 = make_triangle(h1, h0, h3);
Dart_handle d3 = make_triangle(h1, h3, h2);
Dart_handle d4 = make_triangle(h3, h0, h2);
return this->make_combinatorial_tetrahedron(d1, d2, d3, d4);
}
/** Create a tetrahedron given 4 points.
* @param p0 the first point.
* @param p1 the second point.
* @param p2 the third point.
* @param p3 the fourth point.
* @return the dart of the new tetrahedron incident to p0, to edge
* p0,p1 and to facet p0,p1,p2.
*/
Dart_handle make_tetrahedron(const Point& p0,
const Point& p1,
const Point& p2,
const Point& p3)
{
return make_tetrahedron(create_vertex_attribute(p0),
create_vertex_attribute(p1),
create_vertex_attribute(p2),
create_vertex_attribute(p3));
}
/** Create an hexahedron given 8 Vertex_attribute_handle.
* (8 vertices, 12 edges and 6 facets)
* \verbatim
* 4----7
* /| /|
* 5----6 |
* | 3--|-2
* |/ |/
* 0----1
* \endverbatim
* @param h0 the first vertex handle.
* @param h1 the second vertex handle.
* @param h2 the third vertex handle.
* @param h3 the fourth vertex handle.
* @param h4 the fifth vertex handle.
* @param h5 the sixth vertex handle.
* @param h6 the seventh vertex handle.
* @param h7 the height vertex handle.
* @return the dart of the new hexahedron incident to h0, to edge
* h0,h5 and to the facet (h0,h5,h6,h1).
*/
Dart_handle make_hexahedron(Vertex_attribute_handle h0,
Vertex_attribute_handle h1,
Vertex_attribute_handle h2,
Vertex_attribute_handle h3,
Vertex_attribute_handle h4,
Vertex_attribute_handle h5,
Vertex_attribute_handle h6,
Vertex_attribute_handle h7)
{
Dart_handle d1 = make_quadrangle(h0, h5, h6, h1);
Dart_handle d2 = make_quadrangle(h1, h6, h7, h2);
Dart_handle d3 = make_quadrangle(h2, h7, h4, h3);
Dart_handle d4 = make_quadrangle(h3, h4, h5, h0);
Dart_handle d5 = make_quadrangle(h0, h1, h2, h3);
Dart_handle d6 = make_quadrangle(h5, h4, h7, h6);
return this->make_combinatorial_hexahedron(d1, d2, d3, d4, d5, d6);
}
/** Create an hexahedron given 8 points.
* \verbatim
* 4----7
* /| /|
* 5----6 |
* | 3--|-2
* |/ |/
* 0----1
* \endverbatim
* @param p0 the first point.
* @param p1 the second point.
* @param p2 the third point.
* @param p3 the fourth point.
* @param p4 the fifth point.
* @param p5 the sixth point.
* @param p6 the seventh point.
* @param p7 the height point.
* @return the dart of the new hexahedron incident to p0, to edge
* p0,p5 and to the facet (p0,p5,p6,p1).
*/
Dart_handle make_hexahedron(const Point& p0,
const Point& p1,
const Point& p2,
const Point& p3,
const Point& p4,
const Point& p5,
const Point& p6,
const Point& p7)
{
return make_hexahedron(create_vertex_attribute(p0),
create_vertex_attribute(p1),
create_vertex_attribute(p2),
create_vertex_attribute(p3),
create_vertex_attribute(p4),
create_vertex_attribute(p5),
create_vertex_attribute(p6),
create_vertex_attribute(p7));
}
/** Compute the barycenter of a given cell.
* @param adart a dart incident to the cell.
* @param adim the dimension of the cell.
* @return the barycenter of the cell.
*/
template<unsigned int i>
Point barycenter(Dart_const_handle adart) const
{
return CGAL::Barycenter_functor<Self, i>::run(*this, adart);
}
/** Insert a point in a given 1-cell.
* @param dh a dart handle to the 1-cell
* @param p the point to insert
* @param update_attributes a boolean to update the enabled attributes
* @return a dart handle to the new vertex containing p.
*/
Dart_handle insert_point_in_cell_1(Dart_handle dh, const Point& p,
bool update_attributes)
{
return this->insert_cell_0_in_cell_1(dh,
create_vertex_attribute(p),
update_attributes);
}
/** Insert a point in a given 2-cell.
* @param dh a dart handle to the 2-cell
* @param p the point to insert
* @param update_attributes a boolean to update the enabled attributes
* @return a dart handle to the new vertex containing p.
*/
Dart_handle insert_point_in_cell_2(Dart_handle dh, const Point& p,
bool update_attributes)
{
Vertex_attribute_handle v = create_vertex_attribute(p);
Dart_handle first = this->insert_cell_0_in_cell_2(dh, v, update_attributes);
if ( first==null_handle ) // If the triangulated facet was made of one dart
erase_vertex_attribute(v);
#ifdef CGAL_CMAP_TEST_VALID_INSERTIONS
CGAL_assertion( is_valid() );
#endif
return first;
}
/** Insert a point in a given i-cell.
* @param dh a dart handle to the i-cell
* @param p the point to insert
* @param update_attributes a boolean to update the enabled attributes
* @return a dart handle to the new vertex containing p.
*/
template <unsigned int i>
Dart_handle insert_point_in_cell(Dart_handle dh, const Point& p,
bool update_attributes = true)
{
CGAL_static_assertion(1<=i && i<=2);
if (i==1) return insert_point_in_cell_1(dh, p, update_attributes);
return insert_point_in_cell_2(dh, p, update_attributes);
}
/** Insert a dangling edge in a given facet.
* @param dh a dart of the facet (!=NULL).
* @param p the coordinates of the new vertex.
* @param update_attributes a boolean to update the enabled attributes
* @return a dart of the new edge, incident to the new vertex.
*/
Dart_handle insert_dangling_cell_1_in_cell_2(Dart_handle dh,
const Point& p,
bool update_attributes = true)
{
return this->insert_dangling_cell_1_in_cell_2
(dh, create_vertex_attribute(p), update_attributes);
}
/** Insert a point in a given i-cell.
* @param dh a dart handle to the i-cell
* @param p the point to insert
* @param update_attributes a boolean to update the enabled attributes
* @return a dart handle to the new vertex containing p.
*/
template <unsigned int i>
Dart_handle insert_barycenter_in_cell(Dart_handle dh, bool update_attributes = true)
{ return insert_point_in_cell<i>(dh, barycenter<i>(dh), update_attributes); }
/** Compute the dual of a Linear_cell_complex.
* @param alcc the lcc in which we build the dual of this lcc.
* @param adart a dart of the initial lcc, NULL by default.
* @return adart of the dual lcc, the dual of adart if adart!=NULL,
* any dart otherwise.
* As soon as we don't modify this lcc and alcc lcc, we can iterate
* simultaneously through all the darts of the two lcc and we have
* each time of the iteration two "dual" darts.
*/
Dart_handle dual_points_at_barycenter(Self & alcc, Dart_handle adart=null_handle)
{
Dart_handle res = Base::dual(alcc, adart);
// Now the lcc alcc is topologically correct, we just need to add
// its geometry to each vertex (the barycenter of the corresponding
// dim-cell in the initial map).
typename Dart_range::iterator it2 = alcc.darts().begin();
for (typename Dart_range::iterator it(this->darts().begin());
it!=this->darts().end(); ++it, ++it2)
{
if (vertex_attribute(it2)==null_handle)
{
alcc.set_vertex_attribute(it2, alcc.create_vertex_attribute
(barycenter<dimension>(it)));
}
}
return res;
}
/** Set the status of the managment of the attributes of the CMap
*/
void set_update_attributes(bool newval)
{
if (this->automatic_attributes_management == false && newval == true)
{
// We need to recode this function because correct_invalid_attributes
// is not a virtual function.
correct_invalid_attributes();
}
this->automatic_attributes_management = newval;
}
};
// Linear_cell_complex using compact container with handle.
// Linear_cell_complex_for_combinatorial_map class.
// No difference with class Linear_cell_complex_base except the default
// template parameters for Refs class which is a combinatorial map.
template < unsigned int d_, unsigned int ambient_dim = d_,
@ -804,9 +46,9 @@ namespace CGAL {
class Alloc_ = CGAL_ALLOCATOR(int),
template<unsigned int,class,class,class,class>
class CMap = Combinatorial_map_base,
class Storage_ = Linear_cell_complex_storage_1<d_, ambient_dim,
Traits_, Items_,
Alloc_> >
class Storage_ = CMap_linear_cell_complex_storage_1<d_, ambient_dim,
Traits_, Items_,
Alloc_> >
class Linear_cell_complex_for_combinatorial_map:
public Linear_cell_complex_base<d_, ambient_dim, Traits_,
Items_, Alloc_, CMap,
@ -866,36 +108,37 @@ namespace CGAL {
* @param alcc the linear cell complex to copy.
* @post *this is valid.
*/
Linear_cell_complex_for_combinatorial_map(const Self & alcc) : Base()
{ Base::copy/*<Self>*/(alcc); }
Linear_cell_complex_for_combinatorial_map(const Self & alcc) : Base(alcc)
{}
template < class LCC2 >
Linear_cell_complex_for_combinatorial_map(const LCC2& alcc) : Base()
{ Base::copy/*<LCC2>*/(alcc);}
Linear_cell_complex_for_combinatorial_map(const LCC2& alcc) : Base(alcc)
{}
template < class LCC2, typename Converters >
Linear_cell_complex_for_combinatorial_map(const LCC2& alcc,
Converters& converters) : Base()
{ Base::copy/*<LCC2, Converters>*/(alcc, converters);}
Converters& converters) :
Base(alcc, converters)
{}
template < class LCC2, typename Converters, typename DartInfoConverter>
template < class LCC2, typename Converters, typename DartInfoConverter >
Linear_cell_complex_for_combinatorial_map(const LCC2& alcc,
Converters& converters,
const DartInfoConverter&
dartinfoconverter) : Base()
{ Base::copy // TODO REMOVE template copy<LCC2, Converters, Pointconverter>
(alcc, converters, dartinfoconverter); }
dartinfoconverter) :
Base(alcc, converters, dartinfoconverter)
{}
template < class LCC2, typename Converters, typename Pointconverter,
typename DartInfoConverter>
template < class LCC2, typename Converters, typename DartInfoConverter,
typename PointConverter >
Linear_cell_complex_for_combinatorial_map(const LCC2& alcc,
Converters& converters,
const DartInfoConverter&
dartinfoconverter,
const Pointconverter&
pointconverter) : Base()
{ Base::copy//TODO REMOVE ::template copy<LCC2, Converters, Pointconverter, DartInfoConverter>
(alcc, converters, dartinfoconverter, pointconverter); }
const PointConverter&
pointconverter) :
Base(alcc, converters, dartinfoconverter, pointconverter)
{}
};

53
Linear_cell_complex/include/CGAL/Linear_cell_complex_for_generalized_map.h
View File

@ -20,18 +20,20 @@
#ifndef CGAL_LINEAR_CELL_COMPLEX_FOR_GENERALIZED_MAP_H
#define CGAL_LINEAR_CELL_COMPLEX_FOR_GENERALIZED_MAP_H 1
#include <CGAL/Linear_cell_complex.h>
#include <CGAL/Linear_cell_complex_base.h>
#include <CGAL/Linear_cell_complex_traits.h>
#include <CGAL/Linear_cell_complex_min_items.h>
#include <CGAL/Generalized_map.h>
#include <CGAL/GMap_linear_cell_complex_storages.h>
namespace CGAL {
/** @file Linear_cell_complex_for_generalized_map.h
* Definition of a linear cell complex based on generalized map, having points
* associated to all vertices.
* Definition of a linear cell complex based on generalized map, having
* points associated to all vertices.
*/
// GMap_linear_cell_complex using compact container with handle.
// Linear_cell_complex_for_generalized_map class.
// No difference with class Linear_cell_complex_base except the default
// template parameters for Refs class which is a generalized map.
template < unsigned int d_, unsigned int ambient_dim = d_,
@ -44,13 +46,13 @@ namespace CGAL {
Traits_, Items_,
Alloc_> >
class Linear_cell_complex_for_generalized_map:
public Linear_cell_complex_base<d_, ambient_dim, Traits_,
Items_, Alloc_, CMap,
Linear_cell_complex_for_generalized_map
<d_, ambient_dim,
Traits_, Items_,
Alloc_, CMap, Storage_>,
Storage_>
public Linear_cell_complex_base<d_, ambient_dim, Traits_,
Items_, Alloc_, CMap,
Linear_cell_complex_for_generalized_map
<d_, ambient_dim,
Traits_, Items_,
Alloc_, CMap, Storage_>,
Storage_>
{
public:
typedef Linear_cell_complex_for_generalized_map<d_, ambient_dim,
@ -102,36 +104,37 @@ namespace CGAL {
* @param alcc the linear cell complex to copy.
* @post *this is valid.
*/
Linear_cell_complex_for_generalized_map(const Self & alcc) : Base()
{ Base::copy(alcc); }
Linear_cell_complex_for_generalized_map(const Self & alcc) : Base(alcc)
{}
template < class LCC2 >
Linear_cell_complex_for_generalized_map(const LCC2& alcc)
{ Base::copy(alcc);}
Linear_cell_complex_for_generalized_map(const LCC2& alcc) : Base(alcc)
{}
template < class LCC2, typename Converters >
Linear_cell_complex_for_generalized_map(const LCC2& alcc,
Converters& converters)
{ Base::copy(alcc, converters);}
Converters& converters) :
Base(alcc, converters)
{}
template < class LCC2, typename Converters, typename DartInfoConverter >
Linear_cell_complex_for_generalized_map(const LCC2& alcc,
Converters& converters,
const DartInfoConverter&
dartinfoconverter)
{ Base::copy//TODO REMOVE<LCC2, Converters, Pointconverter>
(alcc, converters, dartinfoconverter);}
dartinfoconverter) :
Base(alcc, converters, dartinfoconverter)
{}
template < class LCC2, typename Converters, typename DartInfoConverter,
typename Pointconverter >
typename PointConverter >
Linear_cell_complex_for_generalized_map(const LCC2& alcc,
Converters& converters,
const DartInfoConverter&
dartinfoconverter,
const Pointconverter&
pointconverter)
{ Base::copy//TODO REMOVE<LCC2, Converters, Pointconverter>
(alcc, converters, dartinfoconverter, pointconverter);}
const PointConverter&
pointconverter) :
Base(alcc, converters, dartinfoconverter, pointconverter)
{}
};

52
Linear_cell_complex/include/CGAL/Linear_cell_complex_operations.h
View File

@ -32,7 +32,15 @@ namespace CGAL {
/** @file Linear_cell_complex_operations.h
* Basic operators on a linear cell complex.
*/
namespace internal {
template <class Point, class Vector>
void newell_single_step_3_for_lcc(const Point& p, const Point& q, Vector& n)
{
n = Vector(n.x()+((p.y()-q.y())*(p.z()+q.z())),
n.y()+((p.z()-q.z())*(p.x()+q.x())),
n.z()+((p.x()-q.x())*(p.y()+q.y())));
}
} // End namespace internal
/** Compute the normal of the given facet.
* @param amap the used linear cell complex.
@ -43,46 +51,34 @@ namespace CGAL {
typename LCC::Vector compute_normal_of_cell_2
(const LCC& amap, typename LCC::Dart_const_handle adart)
{
// TODO Better approximation by using Newell's method
// Nx += (Vy - V'y) * (Vz + V'z);
// Ny += (Vz - V'z) * (Vx + V'x);
// Nz += (Vx - V'x) * (Vy + V'y);
// But problem with functor since this is not the sum of normal vectors.
// Compute normal of the face by using Newell's method: for each edge PQ
// Nx += (Py - Qy) * (Pz + Qz);
// Ny += (Pz - Qz) * (Px + Qx);
// Nz += (Px - Qx) * (Py + Qy);
typedef typename LCC::Point Point;
typedef typename LCC::Vector Vector;
typename LCC::Dart_const_handle start=adart;
Vector normal(CGAL::NULL_VECTOR);
while ( !amap.template is_free<0>(start) &&
amap.template beta<0>(start)!=adart )
start = amap.template beta<0>(start);
if ( amap.template is_free<1>(start) ||
amap.other_extremity(amap.template beta<1>(start))==LCC::null_handle )
return normal;
// We go to the beginning of the face (first dart)
while ( amap.is_previous_exist(start) && amap.previous(start)!=adart )
start = amap.previous(start);
// Now we advance to process each edge
unsigned int nb = 0;
adart = amap.template beta<1>(start);
const Point* prev = &amap.point(start);
const Point* curr = &amap.point(adart);
for ( ; adart!=start && amap.other_extremity(adart)!=LCC::null_handle;
adart=amap.template beta<1>(adart) )
for ( adart=start; adart!=start && amap.is_next_exist(adart);
adart=next(adart) )
{
const Point* next = &amap.point( amap.other_extremity(adart));
if ( !typename LCC::Traits::Collinear_3()(*prev, *curr, *next) )
{
normal = typename LCC::Traits::Construct_sum_of_vectors()
(normal, typename LCC::Traits::Construct_normal_3()
(*prev, *curr, *next));
prev = curr;
++nb;
}
const Point* next = &amap.point(amap.other_extremity(adart));
internal::newell_single_step_3_for_lcc(*curr, *next, normal);
++nb;
curr = next;
}
if ( nb<2 ) return normal;
return (typename LCC::Traits::Construct_scaled_vector()(normal, 1.0/nb));
// return normal / std::sqrt(normal * normal);
}