diff --git a/Packages/Alpha_shapes_2/Makefile b/Packages/Alpha_shapes_2/Makefile index 3a6f119c403..8523ce3fed7 100644 --- a/Packages/Alpha_shapes_2/Makefile +++ b/Packages/Alpha_shapes_2/Makefile @@ -68,7 +68,9 @@ clean: $(Package).tar.gz: tar -zcvf $(Package).tar.gz \ - --exclude=CVS --exclude=wrapper.tex \ + --exclude=CVS \ + --exclude=wrapper.tex --exclude=weight.tex \ + --exclude=Weighted_alpha_shape_2.h \ --exclude=Makefile* --exclude=*5000* --exclude=*.o \ --exclude=*.obj --exclude=*.exe --exclude=*~ \ version description.txt changes.txt \ diff --git a/Packages/Alpha_shapes_2/demo/Alpha_shapes_2/demo_alpha.C b/Packages/Alpha_shapes_2/demo/Alpha_shapes_2/demo_alpha.C index 36b9b909150..b9a4e9aa349 100644 --- a/Packages/Alpha_shapes_2/demo/Alpha_shapes_2/demo_alpha.C +++ b/Packages/Alpha_shapes_2/demo/Alpha_shapes_2/demo_alpha.C @@ -1,16 +1,38 @@ // ====================================================================== // -// Copyright (c) 1997 The CGAL Consortium +// Copyright (c) 1999 The GALIA Consortium // -// This software and related documentation is part of an INTERNAL release -// of the Computational Geometry Algorithms Library (CGAL). It is not -// intended for general use. +// This software and related documentation is part of the +// Computational Geometry Algorithms Library (CGAL). +// +// Every use of CGAL requires a license. Licenses come in three kinds: +// +// - For academic research and teaching purposes, permission to use and +// copy the software and its documentation is hereby granted free of +// charge, provided that +// (1) it is not a component of a commercial product, and +// (2) this notice appears in all copies of the software and +// related documentation. +// - Development licenses grant access to the source code of the library +// to develop programs. These programs may be sold to other parties as +// executable code. To obtain a development license, please contact +// the GALIA Consortium (at cgal@cs.uu.nl). +// - Commercialization licenses grant access to the source code and the +// right to sell development licenses. To obtain a commercialization +// license, please contact the GALIA Consortium (at cgal@cs.uu.nl). +// +// This software and documentation is provided "as-is" and without +// warranty of any kind. In no event shall the CGAL Consortium be +// liable for any damage of any kind. +// +// The GALIA Consortium consists of Utrecht University (The Netherlands), +// ETH Zurich (Switzerland), Free University of Berlin (Germany), +// INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg +// (Germany), Max-Planck-Institute Saarbrucken (Germany), +// and Tel-Aviv University (Israel). // // ---------------------------------------------------------------------- // -// release : $CGAL_Revision: CGAL-2.0-I-20 $ -// release_date : $CGAL_Date: 1999/06/02 $ -// // file : demo/Alpha_shapes_2/demo_alpha.C // package : Alpha_shapes_2(1.0) // source : $RCSfile$ diff --git a/Packages/Alpha_shapes_2/demo/Alpha_shapes_2/demo_weight.C b/Packages/Alpha_shapes_2/demo/Alpha_shapes_2/demo_weight.C index 8ba17e6abf8..d848ca50eb1 100644 --- a/Packages/Alpha_shapes_2/demo/Alpha_shapes_2/demo_weight.C +++ b/Packages/Alpha_shapes_2/demo/Alpha_shapes_2/demo_weight.C @@ -1,16 +1,38 @@ // ====================================================================== // -// Copyright (c) 1997 The CGAL Consortium +// Copyright (c) 1999 The GALIA Consortium // -// This software and related documentation is part of an INTERNAL release -// of the Computational Geometry Algorithms Library (CGAL). It is not -// intended for general use. +// This software and related documentation is part of the +// Computational Geometry Algorithms Library (CGAL). +// +// Every use of CGAL requires a license. Licenses come in three kinds: +// +// - For academic research and teaching purposes, permission to use and +// copy the software and its documentation is hereby granted free of +// charge, provided that +// (1) it is not a component of a commercial product, and +// (2) this notice appears in all copies of the software and +// related documentation. +// - Development licenses grant access to the source code of the library +// to develop programs. These programs may be sold to other parties as +// executable code. To obtain a development license, please contact +// the GALIA Consortium (at cgal@cs.uu.nl). +// - Commercialization licenses grant access to the source code and the +// right to sell development licenses. To obtain a commercialization +// license, please contact the GALIA Consortium (at cgal@cs.uu.nl). +// +// This software and documentation is provided "as-is" and without +// warranty of any kind. In no event shall the CGAL Consortium be +// liable for any damage of any kind. +// +// The GALIA Consortium consists of Utrecht University (The Netherlands), +// ETH Zurich (Switzerland), Free University of Berlin (Germany), +// INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg +// (Germany), Max-Planck-Institute Saarbrucken (Germany), +// and Tel-Aviv University (Israel). // // ---------------------------------------------------------------------- // -// release : $CGAL_Revision: CGAL-2.0-I-20 $ -// release_date : $CGAL_Date: 1999/06/02 $ -// // file : demo/Alpha_shapes_2/demo_weight.C // package : Alpha_shapes_2(1.0) // source : $RCSfile$ @@ -54,9 +76,8 @@ #include #include -#include - +#include "weights_heuristic_2.h" #include "Parse_weight.C" #include "Timing.C" diff --git a/Packages/Alpha_shapes_2/demo/Alpha_shapes_2/essai.C b/Packages/Alpha_shapes_2/demo/Alpha_shapes_2/essai.C deleted file mode 100644 index b18403b3d67..00000000000 --- a/Packages/Alpha_shapes_2/demo/Alpha_shapes_2/essai.C +++ /dev/null @@ -1,229 +0,0 @@ -#include - -#include -#include -#include -#include -#include -#include - -// #include -// //#include -// //#include -// //#include -// //#include -// //#include -// #include // to avoid a g++ problem -// #include -// #include -// #include -// #include -#include - -//#include -#include - -#include -#include - -#define CGAL::ALPHA_WINDOW_STREAM -#include - - - -#include "parse.h" - - - -//typedef leda_integer coord_type; -typedef double coord_type; -//typedef leda_real coord_type; -//typedef CGAL::Fixed coord_type; - -typedef CGAL::Cartesian Rep; -//typedef CGAL::Homogeneous Rep; - -//typedef CGAL::Point_2 Point; -//typedef CGAL::Segment_2 Segment; -typedef CGAL::Ray_2 Ray; -typedef CGAL::Line_2 Line; -//typedef CGAL::Triangle_2 Triangle; - - - -typedef CGAL::Alpha_shape_euclidean_traits_2 Gt; -typedef CGAL::Alpha_shape_euclidean_traits_2::Point Point; -typedef CGAL::Alpha_shape_euclidean_traits_2::Segment Segment; -typedef CGAL::Alpha_shape_euclidean_traits_2::Triangle Triangle; - - -typedef CGAL::Alpha_shape_vertex_base_2 Vb; -typedef CGAL::Alpha_shape_face_base_2 Fb; -typedef CGAL::Triangulation_default_data_structure_2 Tds; - - -typedef CGAL::Alpha_shape_2 Alpha_shape_2; - -typedef typename Alpha_shape_2::Face Face; -typedef typename Alpha_shape_2::Vertex Vertex; -typedef typename Alpha_shape_2::Edge Edge; -typedef typename Alpha_shape_2::Face_handle Face_handle; -typedef typename Alpha_shape_2::Vertex_handle Vertex_handle; - -typedef typename Alpha_shape_2::Face_circulator Face_circulator; -typedef typename Alpha_shape_2::Vertex_circulator Vertex_circulator; - -typedef typename Alpha_shape_2::Locate_type Locate_type; - -typedef typename Alpha_shape_2::Face_iterator Face_iterator; -typedef typename Alpha_shape_2::Vertex_iterator Vertex_iterator; -typedef typename Alpha_shape_2::Edge_iterator Edge_iterator; -typedef typename Alpha_shape_2::Edge_circulator Edge_circulator; -typedef typename Alpha_shape_2::Coord_type Coord_type; -typedef typename Alpha_shape_2::Alpha_iterator Alpha_iterator; - -#define CGAL::ALPHA_WINDOW_STREAM -typedef CGAL::Window_stream Window_stream; - -void -random_input(Alpha_shape_2 &A, - CGAL::Window_stream &W) - // Generate random points inside the window - // insert them into the alpha shape -{ - int n = 5; - vector V; - V.reserve(n); - - - - double x0 = W.xmin(); - double y0 = W.ymin(); - double x1 = W.xmax(); - double y1 = W.ymax(); - - double dx = x1 - x0; - double dy = y1 - y0; - - int xmin = int(x0 + 0.1*dx); - int xmax = int(x1 - 0.1*dx); - int ymin = int(y0 + 0.1*dy); - int ymax = int(y1 - 0.1*dy); - - - for(int i = 0; i V; -// V.reserve(3); -// Point p((double) 2,(double) 1); -// V.push_back(p); -// Point p1((double) 1,(double) 1); -// V.push_back(p1); -// Point p2((double) 5,(double) 2); -// V.push_back(p2); - - n = A.make_Alpha_shape(V.begin(),V.end()); - - cerr << "Inserted " << n << " points" << endl; -} - - -void -container_input(Alpha_shape_2 &T, - Window_stream &W) -{ - vector V(3); - V[0] = Point(0, 0); - V[1] = Point(1, 4); - V[2] = Point(3, 4); - - //list Vertices; - int n = T.make_Alpha_shape(V.begin(), V.end()); - cerr << n << " points inserted from a vector." << endl; - -} - -void -window_input(Alpha_shape_2 &T, - Window_stream &W) -{ - cerr << "Enter points with the left button" << endl; - cerr << "Remove points with the middle button" << endl; - cerr << "Right button terminates input of points" << endl; - - Point p; - Point q(coord_type(W.xmin()-1), - coord_type(W.ymin()-1)); - - Face_handle highlight; - Vertex_handle hv; - vector V; - double x, y; - int b,n; - while(1) { - b = W.get_mouse(x,y); - bool button_pressed = (b == MOUSE_BUTTON(1)) || - (b == MOUSE_BUTTON(2)) || - (b == MOUSE_BUTTON(3)); - p = Point(coord_type(x), - coord_type(y)); - bool mouse_moved = p != q; - bool face_change = true, - vertex_change = false; - - if(b == MOUSE_BUTTON(1)) { - W.draw_node(x,y); - V.push_back(p); - - - } else if(b == MOUSE_BUTTON(3)){ - n=T.make_Alpha_shape(V.begin(),V.end()); - cerr << n << " points inserted from a vector." << endl; - W.clear(); - cerr << "Alpha optimal pour 1 cc :" << *(T.find_optimal_alpha(1)) << endl; - T.set_alpha(*(T.find_optimal_alpha(1))); - W << T; - cerr << "Affiche Alpha shape" << endl; - V.erase(V.begin(),V.end()); - return; - } else if(b == MOUSE_BUTTON(2)) - {W.clear();} - - - q = p; - } -} - - -void main() -{ - Alpha_shape_2 T; - Window_stream W(800, 800); // physical window size -// W_global = &W; - - //W.init(opt.min, opt.max, opt.min); // logical window size - W.init(-7,7,-7); - W.set_show_coordinates(true); - W << CGAL::GREEN; - W.display(); - // random_input(T, W); - // container_input(T,W); - while (1){ - window_input(T,W);} - T.set_alpha(4); - - W.clear(); - W << T; - cerr << "Affiche Alpha shape" << endl; - while (1) {}; - -} - diff --git a/Packages/Alpha_shapes_2/demo/Alpha_shapes_2/makefile b/Packages/Alpha_shapes_2/demo/Alpha_shapes_2/makefile index 74aed191875..fc711dbcf35 100644 --- a/Packages/Alpha_shapes_2/demo/Alpha_shapes_2/makefile +++ b/Packages/Alpha_shapes_2/demo/Alpha_shapes_2/makefile @@ -1,3 +1,4 @@ + # This is a makefile exemple for compiling a CGAL application. #---------------------------------------------------------------------# diff --git a/Packages/Alpha_shapes_2/demo/Alpha_shapes_2/weights_heuristic_2.h b/Packages/Alpha_shapes_2/demo/Alpha_shapes_2/weights_heuristic_2.h new file mode 100644 index 00000000000..2423505a948 --- /dev/null +++ b/Packages/Alpha_shapes_2/demo/Alpha_shapes_2/weights_heuristic_2.h @@ -0,0 +1,631 @@ +// ====================================================================== +// +// Copyright (c) 1999 The GALIA Consortium +// +// This software and related documentation is part of the +// Computational Geometry Algorithms Library (CGAL). +// +// Every use of CGAL requires a license. Licenses come in three kinds: +// +// - For academic research and teaching purposes, permission to use and +// copy the software and its documentation is hereby granted free of +// charge, provided that +// (1) it is not a component of a commercial product, and +// (2) this notice appears in all copies of the software and +// related documentation. +// - Development licenses grant access to the source code of the library +// to develop programs. These programs may be sold to other parties as +// executable code. To obtain a development license, please contact +// the GALIA Consortium (at cgal@cs.uu.nl). +// - Commercialization licenses grant access to the source code and the +// right to sell development licenses. To obtain a commercialization +// license, please contact the GALIA Consortium (at cgal@cs.uu.nl). +// +// This software and documentation is provided "as-is" and without +// warranty of any kind. In no event shall the CGAL Consortium be +// liable for any damage of any kind. +// +// The GALIA Consortium consists of Utrecht University (The Netherlands), +// ETH Zurich (Switzerland), Free University of Berlin (Germany), +// INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg +// (Germany), Max-Planck-Institute Saarbrucken (Germany), +// and Tel-Aviv University (Israel). +// +// ---------------------------------------------------------------------- +// +// file : include/CGAL/Weighted_alpha_shape_2.h +// package : Alpha_shapes_2 (1.0) +// source : $RCSfile$ +// revision : $Revision$ +// revision_date : $Date$ +// author(s) : Tran Kai Frank DA +// +// coordinator : INRIA Sophia-Antipolis () +// +// ====================================================================== + +#ifndef CGAL_WEIGHTED_ALPHA_SHAPE_2_H +#define CGAL_WEIGHTED_ALPHA_SHAPE_2_H + +#ifdef CGAL_STL_SGI_CC +#define STL_HASH_TABLES +#endif + +#include + +// SGI MIPSpro C++ 7.x +#ifdef STL_HASH_TABLES +#include +#include +#include +#else +#include +#include +#endif + +#include +#include +#include + +#include +#include + +#include + +//------------------------------------------------------------------- +CGAL_BEGIN_NAMESPACE +//------------------------------------------------------------------- + +template < class Rt > +class Weighted_alpha_shape_2 : public Alpha_shape_2 +{ + + //------------------------- TYPES ------------------------------------ + +public: + typedef typename Alpha_shape_2::Gt Gt; + typedef typename Alpha_shape_2::Triangulation_data_structure Tds; + + typedef typename Gt::Coord_type Coord_type; + typedef typename Gt::Point Point; + + typedef typename Gt::Distance Distance; + typedef typename Gt::Ray Ray; + typedef typename Gt::Line Line; + typedef typename Gt::Direction Direction; + + + typedef typename Alpha_shape_2::Face_handle Face_handle; + typedef typename Alpha_shape_2::Vertex_handle Vertex_handle; + typedef typename Alpha_shape_2::Edge Edge; + + typedef typename Alpha_shape_2::Face_circulator Face_circulator; + typedef typename Alpha_shape_2::Edge_circulator Edge_circulator; + typedef typename Alpha_shape_2::Vertex_circulator Vertex_circulator; + + typedef typename Alpha_shape_2::Face_iterator Face_iterator; + typedef typename Alpha_shape_2::Edge_iterator Edge_iterator; + typedef typename Alpha_shape_2::Vertex_iterator Vertex_iterator; + + typedef typename Alpha_shape_2::Locate_type Locate_type; + + typedef typename Alpha_shape_2::Mode Mode; + +public: + + //------------------------- CONSTRUCTORS ------------------------------ + + // Introduces an empty alpha-shape `A' for a positive + // alpha-value `alpha'. Precondition: `alpha' >= 0. + Weighted_alpha_shape_2(Coord_type alpha = 0, + Mode m = GENERAL) + : Alpha_shape_2(alpha, m) + {} + + // Introduces an alpha-shape `A' for a positive alpha-value + // `alpha' that is initialized with the points in the range + // from first to last + +#ifndef CGAL_CFG_NO_MEMBER_TEMPLATES + + template + Weighted_alpha_shape_2( InputIterator first, + InputIterator last, + const Coord_type& alpha = 0, + Mode = GENERAL) + : Alpha_shape_2(first, last, alpha, m) + {} + +#else //CGAL_CFG_NO_MEMBER_TEMPLATES +#if defined(LIST) || defined(__SGI_STL_LIST) + + Weighted_alpha_shape_2(typename std::list::const_iterator first, + typename std::list::const_iterator last, + const Coord_type& alpha = 0, + Mode m = GENERAL) + : Alpha_shape_2(first, last, alpha, m) + {} + +#endif //LIST + +#if defined(VECTOR) || defined(__SGI_STL_VECTOR) + + Weighted_alpha_shape_2(typename std::vector::const_iterator first, + typename std::vector::const_iterator last, + const Coord_type& alpha = 0, + Mode m = GENERAL) + : Alpha_shape_2(first, last, alpha, m) + {} + +#endif // VECTOR + +#endif //CGAL_CFG_NO_MEMBER_TEMPLATES + + + //---------------heuristic initialization of weights---------------- + +#ifndef CGAL_CFG_NO_MEMBER_TEMPLATES + + template + void + initialize_weights_to_the_nearest_voronoi_vertex + (Iterator first, Iterator last, const Coord_type &k); + + //--------------------------------------------------------------------- + + template + void + initialize_weights_to_the_nearest_voronoi_edge + (Iterator first, Iterator last, const Coord_type &k); + + //--------------------------------------------------------------------- + + template + void + initialize_weights_to_the_nearest_vertex + (Iterator first, Iterator last, const Coord_type &k); + + +#else //CGAL_CFG_NO_MEMBER_TEMPLATES +#if defined(LIST) || defined(__SGI_STL_LIST) + + void + initialize_weights_to_the_nearest_voronoi_vertex + (typename std::list::iterator first, + typename std::list::iterator last, const Coord_type &k); + + //--------------------------------------------------------------------- + + void + initialize_weights_to_the_nearest_voronoi_edge + (typename std::list::iterator first, + typename std::list::iterator last, const Coord_type &k); + + + //--------------------------------------------------------------------- + + void + initialize_weights_to_the_nearest_vertex + (typename std::list::iterator first, + typename std::list::iterator last, const Coord_type &k); + + +#endif //LIST + +#if defined(VECTOR) || defined(__SGI_STL_VECTOR) + + void + initialize_weights_to_the_nearest_voronoi_vertex + (typename std::vector::iterator first, + typename std::vector::iterator last, const Coord_type &k); + + //--------------------------------------------------------------------- + + void + initialize_weights_to_the_nearest_voronoi_edge + (typename std::vector::iterator first, + typename std::vector::iterator last, const Coord_type &k); + + //--------------------------------------------------------------------- + + void + initialize_weights_to_the_nearest_vertex + (typename std::vector::iterator first, + typename std::vector::iterator last, const Coord_type &k); + + //--------------------------------------------------------------------- + + +#endif // VECTOR +#endif // CGAL_CFG_NO_MEMBER_TEMPLATES +}; + +//---------------------- MEMBER FUNCTIONS ----------------------------- + +#ifndef CGAL_CFG_NO_MEMBER_TEMPLATES + +template template +void +Weighted_alpha_shape_2::initialize_weights_to_the_nearest_voronoi_vertex +(Iterator first, Iterator last, const Coord_type &k) +{ + Delaunay_triangulation_2 D; + Iterator point_it; + + D.insert(first, last); + + for( point_it = first; + point_it != last; + ++point_it) + { + Face_circulator face_circ=D.incident_faces(D.nearest_vertex(*point_it)), + done = face_circ; + double d=DBL_MAX; + if (!face_circ.is_empty()) + { + do + { + Face_handle f = face_circ; + if (!D.is_infinite(f)) + { + Point p = D.dual(f); + double dd = squared_distance(p, *point_it); + d = std::min(dd, d); + } + } + while(++face_circ != done); + } + (*point_it) = Point((*point_it).point(), k*k*d); + } +} + + +//--------------------------------------------------------------------- + +template template +void +Weighted_alpha_shape_2::initialize_weights_to_the_nearest_voronoi_edge +(Iterator first, Iterator last, const Coord_type &k) +{ + typedef Delaunay_triangulation_2 Dt_int; + Dt_int D; + Iterator point_it; + + D.insert(first, last); + + for( point_it = first; + point_it != last; + ++point_it) + { + typename Dt_int::Face_circulator face_circ= + D.incident_faces(D.nearest_vertex(*point_it)), + done = face_circ; + + double d = DBL_MAX; + double dd = DBL_MAX; + + if (!face_circ.is_empty()) + { + do + { + typename Dt_int::Face_handle f = face_circ; + if (!D.is_infinite(f)) + { + for ( int i=0; i!=3; ++i) + { + typename Dt_int::Edge e(f,i); + + if ((!D.is_infinite(e.first))&& + (!D.is_infinite(e.first->neighbor(e.second)))) + { + typename Gt::Segment seg(D.dual(e.first), + D.dual(e.first + ->neighbor(e.second))); + dd = squared_distance(seg, *point_it); + } + d = std::min(dd, d); + } + } + } + while(++face_circ != done); + } + if (d != DBL_MAX) + (*point_it) = Point((*point_it).point(), k*k*d); + else + (*point_it) = Point((*point_it).point(), Coord_type(0)); + } +} + + +//--------------------------------------------------------------------- + +template template +void +Weighted_alpha_shape_2::initialize_weights_to_the_nearest_vertex +(Iterator first, Iterator last, const Coord_type &k) +{ + Delaunay_triangulation_2 D; + Iterator point_it; + + D.insert(first, last); + + for( point_it = first; + point_it != last; + ++point_it) + { + + D.remove(D.nearest_vertex(*point_it)); + + Point neighbor = D.nearest_vertex(*point_it)->point(); + + (*point_it) = Point((*point_it).point(),k*k* + squared_distance(neighbor, *point_it)); + + D.insert(*point_it); + } +} + +#else // CGAL_CFG_NO_MEMBER_TEMPLATES + +//------------------------------------------------------------------- + +#if defined(VECTOR) || defined(__SGI_STL_VECTOR) + +template +void +Weighted_alpha_shape_2::initialize_weights_to_the_nearest_voronoi_vertex +(typename std::vector::iterator first, + typename std::vector::iterator last, const Coord_type &k) +{ + Delaunay_triangulation_2 D; + typename std::vector::iterator point_it; + + D.insert(first, last); + + for( point_it = first; + point_it != last; + ++point_it) + { + Face_circulator face_circ=D.incident_faces(D.nearest_vertex(*point_it)), + done = face_circ; + double d=DBL_MAX; + if (!face_circ.is_empty()) + { + do + { + Face_handle f = face_circ; + if (!D.is_infinite(f)) + { + Point p = D.dual(f); + double dd = squared_distance(p, *point_it); + d = std::min(dd, d); + } + } + while(++face_circ != done); + } + (*point_it) = Point((*point_it).point(), k*k*d); + } +} + +//----------------------------------------------------------------------- + +template +void +Weighted_alpha_shape_2::initialize_weights_to_the_nearest_voronoi_edge +(typename std::vector::iterator first, + typename std::vector::iterator last, const Coord_type &k) +{ + typedef Delaunay_triangulation_2 Dt_int; + Dt_int D; + typename std::vector::iterator point_it; + + D.insert(first, last); + + for( point_it = first; + point_it != last; + ++point_it) + { + typename Dt_int::Face_circulator face_circ= + D.incident_faces(D.nearest_vertex(*point_it)), + done = face_circ; + + double d = DBL_MAX; + double dd = DBL_MAX; + + if (!face_circ.is_empty()) + { + do + { + typename Dt_int::Face_handle f = face_circ; + if (!D.is_infinite(f)) + { + for ( int i=0; i!=3; ++i) + { + typename Dt_int::Edge e(f,i); + + if ((!D.is_infinite(e.first))&& + (!D.is_infinite(e.first->neighbor(e.second)))) + { + typename Gt::Segment seg(D.dual(e.first), + D.dual(e.first + ->neighbor(e.second))); + dd = squared_distance(seg, *point_it); + } + d = std::min(dd, d); + } + } + } + while(++face_circ != done); + } + if (d != DBL_MAX) + (*point_it) = Point((*point_it).point(), k*k*d); + else + (*point_it) = Point((*point_it).point(), Coord_type(0)); + } +} + +//----------------------------------------------------------------------- + +template +void +Weighted_alpha_shape_2::initialize_weights_to_the_nearest_vertex +(typename std::vector::iterator first, + typename std::vector::iterator last, const Coord_type &k) +{ + Delaunay_triangulation_2 D; + typename std::vector::iterator point_it; + + D.insert(first, last); + + for( point_it = first; + point_it != last; + ++point_it) + { + + D.remove(D.nearest_vertex(*point_it)); + + Point neighbor = D.nearest_vertex(*point_it)->point(); + + (*point_it) = Point((*point_it).point(),k*k* + squared_distance(neighbor, *point_it)); + D.insert(*point_it); + } +} + +#endif //VECTOR + +//----------------------------------------------------------------------- + +#if defined(LIST) || defined(__SGI_STL_LIST) + +template +void +Weighted_alpha_shape_2::initialize_weights_to_the_nearest_voronoi_vertex +(typename std::list::iterator first, + typename std::list::iterator last, const Coord_type &k) +{ + Delaunay_triangulation_2 D; + typename std::list::iterator point_it; + + D.insert(first, last); + + for( point_it = first; + point_it != last; + ++point_it) + { + Face_circulator face_circ=D.incident_faces(D.nearest_vertex(*point_it)), + done = face_circ; + double d=DBL_MAX; + if (!face_circ.is_empty()) + { + do + { + Face_handle f = face_circ; + if (!D.is_infinite(f)) + { + Point p = D.dual(f); + double dd = squared_distance(p, *point_it); + d = std::min(dd, d); + } + } + while(++face_circ != done); + } + (*point_it) = Point((*point_it).point(), k*k*d); + } +} + +//----------------------------------------------------------------------- + +template +void +Weighted_alpha_shape_2::initialize_weights_to_the_nearest_voronoi_edge +(typename std::list::iterator first, + typename std::list::iterator last, const Coord_type &k) +{ + typedef Delaunay_triangulation_2 Dt_int; + Dt_int D; + typename std::list::iterator point_it; + + D.insert(first, last); + + for( point_it = first; + point_it != last; + ++point_it) + { + typename Dt_int::Face_circulator face_circ= + D.incident_faces(D.nearest_vertex(*point_it)), + done = face_circ; + + double d = DBL_MAX; + double dd = DBL_MAX; + + if (!face_circ.is_empty()) + { + do + { + typename Dt_int::Face_handle f = face_circ; + if (!D.is_infinite(f)) + { + for ( int i=0; i!=3; ++i) + { + typename Dt_int::Edge e(f,i); + + if ((!D.is_infinite(e.first))&& + (!D.is_infinite(e.first->neighbor(e.second)))) + { + typename Gt::Segment seg(D.dual(e.first), + D.dual(e.first + ->neighbor(e.second))); + dd = squared_distance(seg, *point_it); + } + d = std::min(dd, d); + } + } + } + while(++face_circ != done); + } + if (d != DBL_MAX) + (*point_it) = Point((*point_it).point(), k*k*d); + else + (*point_it) = Point((*point_it).point(), Coord_type(0)); + } +} + +//----------------------------------------------------------------------- + +template +void +Weighted_alpha_shape_2::initialize_weights_to_the_nearest_vertex +(typename std::list::iterator first, + typename std::list::iterator last, const Coord_type &k) +{ + Delaunay_triangulation_2 D; + typename std::list::iterator point_it; + + D.insert(first, last); + + for( point_it = first; + point_it != last; + ++point_it) + { + + D.remove(D.nearest_vertex(*point_it)); + + Point neighbor = D.nearest_vertex(*point_it)->point(); + + (*point_it) = Point((*point_it).point(),k*k* + squared_distance(neighbor, *point_it)); + D.insert(*point_it); + } +} + +//------------------------------------------------------------------- + +#endif // LIST +#endif // CGAL_CFG_NO_MEMBER_TEMPLATES + +//------------------------------------------------------------------- +CGAL_END_NAMESPACE +//------------------------------------------------------------------- + +#endif //CGAL_WEIGHTED_ALPHA_2_H diff --git a/Packages/Alpha_shapes_2/doc_tex/Alpha_shapes_2/alpha.tex b/Packages/Alpha_shapes_2/doc_tex/Alpha_shapes_2/alpha.tex index 7474e574854..ff50555bb47 100644 --- a/Packages/Alpha_shapes_2/doc_tex/Alpha_shapes_2/alpha.tex +++ b/Packages/Alpha_shapes_2/doc_tex/Alpha_shapes_2/alpha.tex @@ -1,6 +1,50 @@ +% ====================================================================== +% +% Copyright (c) 1999 The GALIA Consortium +% +% This software and related documentation is part of the +% Computational Geometry Algorithms Library (CGAL). +% +% Every use of CGAL requires a license. Licenses come in three kinds: +% +% - For academic research and teaching purposes, permission to use and +% copy the software and its documentation is hereby granted free of +% charge, provided that +% (1) it is not a component of a commercial product, and +% (2) this notice appears in all copies of the software and +% related documentation. +% - Development licenses grant access to the source code of the library +% to develop programs. These programs may be sold to other parties as +% executable code. To obtain a development license, please contact +% the GALIA Consortium (at cgal@cs.uu.nl). +% - Commercialization licenses grant access to the source code and the +% right to sell development licenses. To obtain a commercialization +% license, please contact the GALIA Consortium (at cgal@cs.uu.nl). +% +% This software and documentation is provided "as-is" and without +% warranty of any kind. In no event shall the CGAL Consortium be +% liable for any damage of any kind. +% +% The GALIA Consortium consists of Utrecht University (The Netherlands), +% ETH Zurich (Switzerland), Free University of Berlin (Germany), +% INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg +% (Germany), Max-Planck-Institute Saarbrucken (Germany), +% and Tel-Aviv University (Israel). +% +% ---------------------------------------------------------------------- +% +% package : Alpha_shapes_2 +% author(s) : Tran Kai Frank DA +% +% coordinator : INRIA Sophia-Antipolis () +% +% ====================================================================== + \RCSdef{\alphashapeRevision}{$Revision$} \RCSdefDate{\alphashapeDate}{$Date$} +%---------------------------------------------------------------------- + \chapter{Alpha-Shapes} \label{I1_ChapterAlphashapes} \ccChapterSubTitle{\alphashapeRevision, \alphashapeDate} @@ -8,8 +52,7 @@ \section{Introduction} This chapter presents a framework for alpha shapes. The description is based on -the articles \cite{em-tdas-94,e-was-92}. Alpha shapes can be used for shape -reconstruction from a dense unorganized set of data points. Alpha shapes are +the articles \cite{em-tdas-94,e-was-92}. Alpha shapes are the generalization of the convex hull of a point set. Let $S$ be a finite set of points in $\R^d$, $d = 2,3$ and $\alpha$ a parameter with $0 \leq \alpha \leq \infty$. For $\alpha = \infty$, the $\alpha$-shape is the convex hull of $S$. As @@ -17,14 +60,16 @@ $\alpha$ decreases, the $\alpha$-shape shrinks and develops cavities, as soon as a sphere of radius $\sqrt{\alpha}$ can be put inside. Finally, for $\alpha = 0$, the $\alpha$-shape is the set $S$ itself. -We can describe two versions of alpha shapes, one is based on the Delaunay +We distinguish two versions of alpha shapes, one is based on the Delaunay triangulation and the other on its generalization, the regular triangulation, replacing the natural distance by the power to weighted points. The metric used determines an underlying triangulation of the alpha shape and thus, the version computed. -In one hand, there is the classic alpha shapes associated with the Delaunay triangulations -(cf. \ref{I1_Sect_Delaunay}), in the other hand, the weighted alpha shapes -associated with the regular triangulations (cf. \ref{I1_Sect_Regular}). +In one hand, there is the {\em classic alpha shapes} +(cf. \ref{I1_SectClassicAS}) associated with the Delaunay triangulations +(cf. \ref{I1_Sect_Delaunay}), in the other hand, the {\em weighted alpha shapes} +(cf. \ref{I1_SectWeightedAS}) associated with the regular triangulations +(cf. \ref{I1_Sect_Regular}). There is a close connection between alpha shapes and the underlying triangulations. More precisely, the $\alpha$-complex of $S$ is a @@ -34,9 +79,7 @@ open disk (resp.\ ball) of radius $\sqrt{\alpha}$ through the vertices of the simplex that does not contain any other point of $S$, for the metric used in the computation of the underlying triangulation. The corresponding $\alpha$-shape is defined as the underlying interior space of the -$\alpha$-complex. The $\alpha$-shape is demarcated by a frontier, which is, -under conditions described in \cite{bb-srmua-97t}, a linear approximation of the -original contour. +$\alpha$-complex. In general, an $\alpha$-complex is a non-connected and non-pure polytope, it means, that one $k$-simplice, $0 \leq k \leq d-1$ is not necessary adjacent to @@ -44,7 +87,7 @@ a $(k+1)$-simplice. The $\alpha$-shapes of $S$ form a discrete family, even though they are defined for all real numbers $\alpha$ with $0 \leq \alpha -\leq \infty$. Thus, we can represent the entire family of $\alpha$ shapes +\leq \infty$. Thus, we can represent the entire family of $\alpha$-shapes of $S$ by the underlying triangulation of $S$. In this representation each $k$-simplex of the underlying triangulation is associated with an interval that specifies for which values of $\alpha$ the $k$-simplex @@ -54,6 +97,13 @@ easily. Furthermore, we can select an appropriate $\alpha$-shape from a finite number of different $\alpha$-shapes and corresponding $\alpha$-values. +\subsection*{Main Application} + +Alpha shapes can be used for shape reconstruction from a dense unorganized set +of data points. The $\alpha$-shape is demarcated by a frontier, which is, under +conditions described for the classic version in \cite{bb-srmua-97t}, a linear +approximation of the original contour. + %---------------------------------------------------------------------- \section{Generic Alpha-Shapes of Points in a Plane \label{I1_SectAlpha_Shape_2}} @@ -61,25 +111,25 @@ $\alpha$-values. \begin{ccClassTemplate} {Alpha_shape_2
} \ccDefinition + The class \ccClassTemplateName\ represents the family of $\alpha$-shapes of points in a plane for {\em all} positive -$\alpha$. It maintains the underlying triangulation \ccStyle{Dt} which +$\alpha$. It maintains the underlying triangulation \ccc{Dt} which represents connectivity and order among its faces. Each -$k$-dimensional face of the \ccStyle{Dt} is associated with +$k$-dimensional face of the \ccc{Dt} is associated with an interval that specifies for which values of $\alpha$ the face belongs to the $\alpha$-shape. There are links between the intervals and the $k$-dimensional faces of the triangulation. - \ccInclude{CGAL/Alpha_shape_2.h} \ccInheritsFrom -\ccStyle{Dt} +\ccc{Dt} This class is the underlying triangulation class. -The modifying functions \ccStyle{insert} and \ccStyle{remove} will overwrite +The modifying functions \ccc{insert} and \ccc{remove} will overwrite the inherited functions. At the moment, only the static version is implemented. \ccTypes @@ -87,24 +137,24 @@ the inherited functions. At the moment, only the static version is implemented. \ccThreeToTwo \ccNestedType{Gt}{the alpha shape traits type.} -it contains a Delaunay triangulation traits class. For example \ccStyle{Dt::Point} is a Point class. +it contains a Delaunay triangulation traits class. For example \ccc{Dt::Point} is a Point class. \ccTypedef{typedef Gt::Coord_type Coord_type;}{the number type for computation.} \ccNestedType{Alpha_iterator}{An iterator that allow to traverse the increasing sequence of different $\alpha$-values. The iterator is -bidirectional and non-mutable. Its \ccStyle{value_type} -is \ccStyle{Coord_type}} +bidirectional and non-mutable. Its \ccc{value_type} +is \ccc{Coord_type}} \ccEnum{enum Classification_type {EXTERIOR, SINGULAR, REGULAR, INTERIOR};} {Distinguishes the different cases for classifying a $k$-dimensional face of the underlying triangulation of the $\alpha$-shape. \\ -\ccStyle{EXTERIOR} if the face does not belong to the $\alpha$-complex.\\ -\ccStyle{SINGULAR} if the face belongs to the boundary of the $\alpha$-shape, +\ccc{EXTERIOR} if the face does not belong to the $\alpha$-complex.\\ +\ccc{SINGULAR} if the face belongs to the boundary of the $\alpha$-shape, but is not incident to any 2-dimensional face of the $\alpha$-complex\\ -\ccStyle{REGULAR} if the face belongs to the boundary of the $\alpha$-shape +\ccc{REGULAR} if the face belongs to the boundary of the $\alpha$-shape and is incident to a 2-dimensional face of the $\alpha$-complex\\ -\ccStyle{INTERIOR} if the face belongs to the $\alpha$-complex, but does +\ccc{INTERIOR} if the face belongs to the $\alpha$-complex, but does not belong to the boundary of the $\alpha$-shape\\} \ccEnum{enum Mode {GENERAL, REGULARIZED};} @@ -118,8 +168,8 @@ and their vertices} \ccConstructor{Alpha_shape_2(Coord_type alpha = 0, Mode m = GENERAL);} {Introduces an empty $\alpha$-shape \ccVar\ for a positive $\alpha$-value - \ccStyle{alpha}. -\ccPrecond \ccStyle{alpha}~$\geq~0$.} + \ccc{alpha}. +\ccPrecond \ccc{alpha}~$\geq~0$.} \ccConstructor{template < class InputIterator > @@ -129,12 +179,12 @@ and their vertices} const Coord_type& alpha = 0, Mode m = GENERAL);} {Initializes the family of alpha-shapes with the points in the range -$\left[\right.$\ccStyle{first}, \ccStyle{last}$\left.\right)$ and +$\left[\right.$\ccc{first}, \ccc{last}$\left.\right)$ and introduces an $\alpha$-shape \ccVar\ for a positive $\alpha$-value -\ccStyle{alpha}. -\ccPrecond The \ccStyle{value_type} of \ccStyle{first} and -\ccStyle{last} is \ccStyle{Point}.\\ -\ccStyle{alpha} $\geq 0$.} +\ccc{alpha}. +\ccPrecond The \ccc{value_type} of \ccc{first} and +\ccc{last} is \ccc{Point}.\\ +\ccc{alpha} $\geq 0$.} \ccOperations @@ -145,14 +195,14 @@ introduces an $\alpha$-shape \ccVar\ for a positive $\alpha$-value const Coord_type& alpha = 0, Mode m = GENERAL);} {Initialize the family of alpha-shapes with the points in the range -$\left[\right.$\ccStyle{first}, \ccStyle{last}$\left.\right)$ and +$\left[\right.$\ccc{first}, \ccc{last}$\left.\right)$ and introduces an $\alpha$-shape \ccVar\ for a positive $\alpha$-value -\ccStyle{alpha}. Returns the number of inserted points. \\ +\ccc{alpha}. Returns the number of inserted points. \\ If the function is applied to an non-empty family of alpha-shape, it is cleared before initialization. -\ccPrecond The \ccStyle{value_type} of \ccStyle{first} and -\ccStyle{last} is \ccStyle{Point}.\\ -\ccStyle{alpha} $\geq 0$.} +\ccPrecond The \ccc{value_type} of \ccc{first} and +\ccc{last} is \ccc{Point}.\\ +\ccc{alpha} $\geq 0$.} \ccMethod{void clear();} @@ -160,9 +210,9 @@ before initialization. \ccMethod{Coord_type set_alpha(const Coord_type& alpha);} -{Sets the $\alpha$-value to \ccStyle{alpha}. +{Sets the $\alpha$-value to \ccc{alpha}. Returns the previous $\alpha$-value. -\ccPrecond \ccStyle{alpha} $\geq 0$.} +\ccPrecond \ccc{alpha} $\geq 0$.} \ccMethod{const Coord_type& get_alpha(void) const;} @@ -170,7 +220,7 @@ before initialization. \ccMethod{const Coord_type& get_nth_alpha(int n) const;} {Returns the $n$-th alpha-value, sorted in an increasing order. - \ccPrecond \ccStyle{n} < number of alphas.} + \ccPrecond \ccc{n} < number of alphas.} \ccMethod{int number_of_alphas() const;} {Returns the number of different alpha-values.} @@ -178,9 +228,9 @@ before initialization. % dynamic version % % \ccMethod{Vertex_handle insert(const Point& p);} -% {Inserts point \ccStyle{p} in the alpha shape and returns the +% {Inserts point \ccc{p} in the alpha shape and returns the % corresponding vertex of the underlying Delaunay triangulation.\\ If -% point \ccStyle{p} coincides with an already existing vertex, this +% point \ccc{p} coincides with an already existing vertex, this % vertex is returned and the alpha shape remains unchanged.\\ Otherwise, % the vertex is inserted in the underlying Delaunay triangulation and % the associated intervals are updated. } @@ -204,8 +254,8 @@ Returns the previous mode.} OutputIterator get_alpha_shape_vertices( OutputIterator result);} {Writes the vertices of the alpha shape \ccVar\ for the current $\alpha$-value -to the container where \ccStyle{result} refers to. -The \ccStyle{value_type} of \ccStyle{result} is \ccStyle{Vertex_handle}. +to the container where \ccc{result} refers to. +The \ccc{value_type} of \ccc{result} is \ccc{Vertex_handle}. Returns an output iterator which is the end of the constructed range.} \ccMethod{template < class OutputIterator > @@ -213,8 +263,8 @@ Returns an output iterator which is the end of the constructed range.} OutputIterator result);} {Writes the edges of the alpha shape \ccVar\ for the current $\alpha$-value -to the container where \ccStyle{result} refers to. -The \ccStyle{value_type} of \ccStyle{result} is \ccStyle{pair}. +to the container where \ccc{result} refers to. +The \ccc{value_type} of \ccc{result} is \ccc{pair}. Returns an output iterator which is the end of the constructed range.} \ccHeading{Predicates} @@ -223,26 +273,26 @@ Returns an output iterator which is the end of the constructed range.} \ccMethod{Classification_type classify(const Point& p, const Coord_type& alpha = get_alpha()) const;} -{Locates a point \ccStyle{p} in the underlying triangulation and Classifies the +{Locates a point \ccc{p} in the underlying triangulation and Classifies the associated k-face with respect to \ccVar.} \ccMethod{Classification_type classify(Face_handle f, const Coord_type& alpha = get_alpha()) const;} -{Classifies the face \ccStyle{f} of the underlying triangulation with respect to \ccVar.} +{Classifies the face \ccc{f} of the underlying triangulation with respect to \ccVar.} \ccMethod{Classification_type classify(pair e, const Coord_type& alpha = get_alpha()) const;} -{Classifies the edge \ccStyle{e} of the underlying triangulation with respect to \ccVar.} +{Classifies the edge \ccc{e} of the underlying triangulation with respect to \ccVar.} \ccMethod{Classification_type classify(Face_handle f, int i, const Coord_type& alpha = get_alpha()) const;} -{Classifies the edge of the face \ccStyle{f} opposite to the vertex with index -\ccStyle{i} +{Classifies the edge of the face \ccc{f} opposite to the vertex with index +\ccc{i} of the underlying triangulation with respect to \ccVar.} \ccMethod{Classification_type classify(Vertex_handle v, const Coord_type& alpha = get_alpha()) const;} -{Classifies the vertex \ccStyle{v} of the underlying triangulation with respect to \ccVar.} +{Classifies the vertex \ccc{v} of the underlying triangulation with respect to \ccVar.} \ccHeading{Traversal of the $\alpha$-Values} @@ -251,7 +301,7 @@ of the underlying triangulation with respect to \ccVar.} The alpha shape class defines an iterator that allows to visit the sorted sequence of $\alpha$-values. This iterator is non-mutable and bidirectional. Its value type is -\ccStyle{Coord_type}. +\ccc{Coord_type}. \ccMethod{Alpha_iterator alpha_begin() const;} {Returns an iterator that allows to traverse the @@ -262,16 +312,16 @@ sorted sequence of $\alpha$-values of the family of alpha shapes.} \ccMethod{Alpha_iterator alpha_find(const Coord_type& alpha) const;} {Returns an iterator pointing to an element with $\alpha$-value -\ccStyle{alpha}, or the corresponding past-the-end iterator if such +\ccc{alpha}, or the corresponding past-the-end iterator if such an element is not found.} \ccMethod{Alpha_iterator alpha_lower_bound(const Coord_type& alpha) const;} {Returns an iterator pointing to the first element with -$\alpha$-value not less than \ccStyle{alpha}.} +$\alpha$-value not less than \ccc{alpha}.} \ccMethod{Alpha_iterator alpha_upper_bound(const Coord_type& alpha) const;} {Returns an iterator pointing to the first element with $\alpha$-value -greater than \ccStyle{alpha}.} +greater than \ccc{alpha}.} \ccHeading{Operations} @@ -283,14 +333,14 @@ regularized version.} \ccMethod{Alpha_iterator find_optimal_alpha(int nb_components) const;} {Returns an iterator pointing to the first element with $\alpha$-value such that \ccVar\ satisfies the following two properties:\\ -\ccStyle{nb_components} equals the number of solid components and \\ +\ccc{nb_components} equals the number of solid components and \\ all data points are either on the boundary or in the interior of the regularized version of \ccVar.\\ If no such value is found, the iterator points to the first element with $\alpha$-value such that \ccVar\ satisfies the second property.} \ccHeading{I/O} -The I/O operators are defined for \ccStyle{iostream}, and for +The I/O operators are defined for \ccc{iostream}, and for the window stream provided by \cgal. The format for the iostream is an internal format. @@ -298,8 +348,8 @@ is an internal format. \ccFunction{ostream& operator<<(ostream& os, const Alpha_shape_2
& A);} -{Inserts the alpha shape \ccVar\ for the current $\alpha$-value into the stream \ccStyle{os}. -\ccPrecond The insert operator must be defined for \ccStyle{Point}.} +{Inserts the alpha shape \ccVar\ for the current $\alpha$-value into the stream \ccc{os}. +\ccPrecond The insert operator must be defined for \ccc{Point}.} \ccInclude{CGAL/IO/Window_stream.h} @@ -307,16 +357,16 @@ is an internal format. \ccFunction{Window_stream& operator<<(Window_stream& W, const Alpha_shape_2
& A);} -{Inserts the alpha shape \ccVar\ for the current $\alpha$-value into the window stream \ccStyle{W}. -\ccPrecond The insert operator must be defined for \ccStyle{Point} and \ccStyle{Segment}.} +{Inserts the alpha shape \ccVar\ for the current $\alpha$-value into the window stream \ccc{W}. +\ccPrecond The insert operator must be defined for \ccc{Point} and \ccc{Segment}.} \end{ccClassTemplate} \ccImplementation In the first static version, the set of intervals associated with the $k$-dimensional faces of the underlying triangulation are -stored only as sorted \ccStyle{vectors}. By using an interval tree the +stored only as sorted \ccc{vectors}. By using an interval tree the alpha-shape could be constructed more efficiently. For the dynamic -version, we need \ccStyle{multimaps} or dynamic interval trees. +version, we need \ccc{multimaps} or dynamic interval trees. The cross links between the intervals and the $k$-dimensional faces of the triangulation are actually realized using methods in the $k$-dimensional faces @@ -324,43 +374,46 @@ themselves. By this way, you can decide if you want to store or re-compute any of these informations. -\ccStyle{A.alpha find} uses linear search, while -\ccStyle{A.alpha lower bound} and \ccStyle{A.alpha upper bound} +\ccc{A.alpha find} uses linear search, while +\ccc{A.alpha lower bound} and \ccc{A.alpha upper bound} use binary search. -\ccStyle{A.number solid components} performs a graph traversal and takes time +\ccc{A.number solid components} performs a graph traversal and takes time linear in the number of faces of the underlying triangulation. -\ccStyle{A.find optimal alpha} uses binary search and takes time +\ccc{A.find optimal alpha} uses binary search and takes time $O(\mbox{ \em n } \log{\mbox{ \em n } })$, where $n$ is the number of points. %---------------------------------------------------------------------- \section{The Underlying Triangulation\label{I1_SectDtClass}} -The class \ccStyle{Dt} must be parameterized with a special alpha shape -traits class and a triangulation data structure, with no more requirements as +For the \ccc{Dt} class, you have to choose between a Delaunay or a regular +triangulation, depending the version of alpha shapes, you want. + +The class \ccc{Dt} must be parameterized with a special alpha shape +traits class and a simple triangulation data structure, with no more requirements as for a simple triangulation class, but parameterized by a special vertex base class and a special face base class. -\section*{The Alpha-Shape Traits Class\label{I1_ASTraits}} +\section*{The Alpha-Shape Traits Class (\mbox{\it Gt})\label{I1_ASTraits}} \subsection{Requirements for the Alpha-Shape Traits Class} First, this traits class has the same requirements as the -triangulation traits class, for the \ccStyle{Dt} triangulation, you choose. +triangulation traits class, for the \ccc{Dt} triangulation, you opted. The following requirement catalog lists the primitives that must be defined additionally. \begin{ccClass} {Gt} -\subsection*{Alpha Shape Traits (\mbox{\it Gt})} +\subsection*{\protect \ccc{Alpha_shape_traits} (\mbox{\it Gt})} \ccCreationVariable{t} \ccDefinition -A class \ccClassName\ that satisfies the requirements of a alpha shape -traits class must provide the following predicate and operations in -addition to the requirements for the Delaunay triangulation traits -class. +A class \ccClassName\ that satisfies the requirements of a +\ccc{Alpha_shape_traits} class must provide the following predicate and +operations in addition to the requirements for the underlying triangulation +traits class. \ccTypes @@ -368,15 +421,9 @@ class. The type must provide a copy constructor, assignment, comparison operators, negation, multiplication, division and allow the declaration and initialization with a small integer constant -(cf. requirements for number types). An obvious choice would be -coordinate type of the point class.} +(cf. requirements for number types). +\ccPrecond An obvious choice would be coordinate type of the point class.} -\ccNestedType{Coord_type}{A type to hold a coordinate type class. -The type must provide a copy constructor, assignment, comparison -operators, negation, multiplication, division and allow the -declaration and initialization with a small integer constant -(cf. requirements for number types). An obvious choice would be -coordinate type of the point class.} \ccCreation Only a default constructor is required. Note that further constructors @@ -391,30 +438,30 @@ can be provided. const Point& p1, const Point& p2) const;} {Returns the squared radius of the circle of the -points \ccStyle{p0, p1, p2}, associated with the metric -used by \ccStyle{Dt}.} +points \ccc{p0, p1, p2}, associated with the metric +used by \ccc{Dt}.} \ccMethod{Coord_type squared_radius(const Point& p0, const Point& p1) const;} {Returns the squared radius of smallest circle of the -points \ccStyle{p0, p1}, associated with the metric -used by \ccStyle{Dt}.} +points \ccc{p0, p1}, associated with the metric +used by \ccc{Dt}.} \ccHeading{Predicate} \ccMethod{Bounded_side side_of_circle(const Point& p0, const Point& p1, const Point& test) const;} -{Returns the relative position of point \ccStyle{test} to the smallest circle of -the points \ccStyle{p0, p1}, using the same metric as \ccStyle{Dt}.} +{Returns the relative position of point \ccc{test} to the smallest circle of +the points \ccc{p0, p1}, using the same metric as \ccc{Dt}.} \end{ccClass} -\section*{Triangulation Data Structure Class for an Alpha-Shape} +\section*{Triangulation Data Structure Class (\mbox{\it Tds}) for an Alpha-Shape} -The class \ccStyle{Alpha_shape_2
} parameterized with a -triangulation data structure class \ccStyle{Tds}, that has exactly the same +The class \ccc{Alpha_shape_2
} parameterized with a +triangulation data structure class \ccc{Tds}, that has exactly the same requirements as the triangulation data structure class for a simple triangulation. @@ -428,7 +475,7 @@ Alpha-Shape\label{I1_SectVertex}} The information about the alpha values associated are accessible by the vertices of the alpha shape. Thus the nested \ccc{Alpha_shape_vertex_base} -type of a alpha shape offers additional functionalities to deal with these +type of an alpha shape offers additional functionalities to deal with these methods. This additional functionalities related to the Alpha Shape @@ -439,7 +486,7 @@ They are listed below as such. \ccInheritsFrom -\ccStyle{Triangulation_vertex_base} +\ccc{Triangulation_vertex_base} \begin{ccClass}{Alpha_shape_vertex_base} @@ -453,8 +500,8 @@ operators, negation, multiplication, division and allow the declaration and initialization with a small integer constant (cf. requirements for number types). An obvious choice would be coordinate type of the point class. -\ccPrecond Let's us precise that \ccStyle{Coord_type} has to be the same as the one used by -the \ccStyle{Gt}, already used by underlying triangulation \ccStyle{Dt}.} +\ccPrecond Let's us precise that \ccc{Coord_type} has to be the same as the one used by +the \ccc{Gt}, already used by underlying triangulation \ccc{Dt}.} \ccCreation @@ -496,27 +543,27 @@ for $\alpha$ under $\alpha_1$, the vertex is regular.} The information about the alpha values, associated to the face herself and the incident edges, are accessible by the faces of the alpha shape. Thus the nested \ccc{Alpha_shape_face_base} -type of a alpha shape offers additional functionalities to deal with these +type of an alpha shape offers additional functionalities to deal with these methods. -\ccStyle{Df} has to be choosed as the face base for the underlying triangulation. +\ccc{Df} has to be choosed as the face base for the underlying triangulation. This additional functionalities related to the alpha shape are requirements which have to be fulfilled by the base face for an alpha shape, -in addition to the functionalities required by an underlying triangulation face \ccStyle{Df}. +in addition to the functionalities required by an underlying triangulation face \ccc{Df}. They are listed below as such. \ccInheritsFrom -\ccStyle{Df} +\ccc{Df} \begin{ccClass}{Alpha_shape_face_base} \ccCreationVariable{f} \ccTypes -\ccNestedType{Interval_3}{A container to get (and put) the three special values +\ccNestedType{Interval_3}{A container type to get (and put) the three special values ($\alpha_1, \alpha_2, \alpha_3$) associated with an alpha shape edge.} \ccNestedType{Coord_type}{A type to hold a coordinate type class. @@ -525,9 +572,9 @@ operators, negation, multiplication, division and allow the declaration and initialization with a small integer constant (cf. requirements for number types). An obvious choice would be coordinate type of the point class. -\ccPrecond Let's us precise that \ccStyle{Coord_type} has to be the same as the one used by -\ccStyle{Gt}, already used by the underlying triangulation \ccStyle{Dt}, and by -her face base \ccStyle{Df}.} +\ccPrecond Let's us precise that \ccc{Coord_type} has to be the same as the one used by +\ccc{Gt}, already used by the underlying triangulation \ccc{Dt}, and by +her face base \ccc{Df}.} \ccCreation @@ -575,18 +622,18 @@ face.} %---------------------------------------------------------------------- -\section{Classic Version of Alpha-Shape} +\section{Classic Version of Alpha-Shape\label{I1_SectClassicAS}} \subsection*{The Underlying Triangulation~: a Delaunay Triangulation} For a simple alpha shape, you have to choose a Delaunay triangulation as -underlying triangulation \ccStyle{Dt} and follow the requirements listed above. +underlying triangulation \ccc{Dt} and follow the requirements listed above. \ccInclude{CGAL/Delaunay_triangulation_2.h} -\subsection*{Predefined Geometric Traits Class} +\subsection*{Predefined Geometric Traits Class (\mbox{\it Gt})} -Of course, \cgal\ provides a default \ccc{Alpha_shape_traits} class in this +Of course, \cgal\ provides a default \ccc{Alpha_shape_traits} class in this case, with an implementation of the appropriate predicate and constructions. The class \ccc{Alpha_shape_euclidean_traits_2} simply derived from \ccc{Triangulation_euclidean_traits_2}. @@ -632,18 +679,18 @@ typedef CGAL::Alpha_shape_2
Alpha_shape_2; %---------------------------------------------------------------------- -\section{Weighted Version of Alpha-Shape} +\section{Weighted Version of Alpha-Shape\label{I1_SectWeightedAS}} \subsection*{The Underlying Triangulation~: a Regular Triangulation} For a weighted alpha shape, you have to choose a regular triangulation as -underlying triangulation \ccStyle{Dt} and follow the requirements listed above. +underlying triangulation \ccc{Dt} and follow the requirements listed above. \ccInclude{CGAL/Regular_triangulation_2.h} -\subsection*{Predefined Geometric Traits Class} +\subsection*{Predefined Geometric Traits Class (\mbox{\it Gt})} -Of course, \cgal\ provides a default \ccc{Alpha_shape_traits} class in this +Of course, \cgal\ provides a default \ccc{Alpha_shape_traits} class in this case, with an implementation of the appropriate predicate and constructions. The class \ccc{Weighted_alpha_shape_euclidean_traits_2} simply derived from \ccc{Regular_euclidean_traits_2}. @@ -686,76 +733,3 @@ typedef CGAL::Triangulation_default_data_structure_2 Tds; typedef CGAL::Regular_triangulation_2 Rt; typedef CGAL::Alpha_shape_2 Alpha_shape_2; \end{cprog} - -%---------------------------------------------------------------------- - -\section{Additional Functionalities for Weighted Alpha-Shape\label{I2_SectWeighted_Alpha_Shape_2}} - -\begin{ccClassTemplate} {Weighted_alpha_shape_2} - -\ccDefinition -Specially for the weighted version, the computation of alpha shape often -enforces an estimation of weights for the sample of points. This class -\ccClassTemplateName\ provides some heuristic methods to initialize these -weights in two dimensions. They can deal with samples of points extract from a -contour in a plane. The main idea is to control an union of sphere, dual of the -weighted alpha shape, which has to preserve the skeleton of the original -contour. The best results are in \ccc{GENERAL} mode, with $\alpha=0$. - -\ccInclude{CGAL/Weighted_alpha_shape_2.h} - -\ccInheritsFrom - -\ccStyle{Alpha_shape_2} - -This\ccClassTemplateName\ has exactly the same requirements as the -\ccc{Alpha_shape_2} class, used for the weighted version of alpha shape. - -\ccCreation -\ccCreationVariable{A} - -\ccConstructor{Weighted_alpha_shape_2(Coord_type alpha = 0, - Mode m = GENERAL);} -{Introduces an empty $\alpha$-shape \ccVar\ for a positive $\alpha$-value - \ccStyle{alpha}. -\ccPrecond \ccStyle{alpha}~$\geq~0$.} - - -\ccConstructor{template < class InputIterator > - Weighted_alpha_shape_2( - InputIterator first, - InputIterator last, - const Coord_type& alpha = 0, - Mode m = GENERAL);} -{Initializes the family of alpha-shapes with the weighted points in the range -$\left[\right.$\ccStyle{first}, \ccStyle{last}$\left.\right)$ and -introduces an $\alpha$-shape \ccVar\ for a positive $\alpha$-value -\ccStyle{alpha}. -\ccPrecond The \ccStyle{value_type} of \ccStyle{first} and -\ccStyle{last} is \ccStyle{Weighted_point}.\\ -\ccStyle{alpha} $\geq 0$.} - -\ccOperations - -\ccMethod{template < class Iterator > -void -initialize_weights_to_the_nearest_voronoi_vertex -(Iterator first, Iterator last, const Coord_type& k);} -{initialize the weight of each point, stored in a container of points, with a value -equal to the distance to his nearest Voronoi vertex multiply by $k \leq 1$.} - -\ccMethod{template < class Iterator > -void -initialize_weights_to_the_nearest_voronoi_edge -(Iterator first, Iterator last, const Coord_type& k);} -{initialize the weight of each point, stored in a container of points, with a -value equal to the distance to his nearest Voronoi edge multiply by $k \geq 1$.} - -\ccMethod{template < class Iterator > -void -initialize_weights_to_the_nearest_vertex -(Iterator first, Iterator last, const Coord_type& k);} -{initialize the weight of each point, stored in a container of points, with a -value equal to the distance to his nearest vertex multiply by $k$.} - -\end{ccClassTemplate} diff --git a/Packages/Alpha_shapes_2/doc_tex/basic/Alpha_shapes_2/alpha.tex b/Packages/Alpha_shapes_2/doc_tex/basic/Alpha_shapes_2/alpha.tex index 7474e574854..ff50555bb47 100644 --- a/Packages/Alpha_shapes_2/doc_tex/basic/Alpha_shapes_2/alpha.tex +++ b/Packages/Alpha_shapes_2/doc_tex/basic/Alpha_shapes_2/alpha.tex @@ -1,6 +1,50 @@ +% ====================================================================== +% +% Copyright (c) 1999 The GALIA Consortium +% +% This software and related documentation is part of the +% Computational Geometry Algorithms Library (CGAL). +% +% Every use of CGAL requires a license. Licenses come in three kinds: +% +% - For academic research and teaching purposes, permission to use and +% copy the software and its documentation is hereby granted free of +% charge, provided that +% (1) it is not a component of a commercial product, and +% (2) this notice appears in all copies of the software and +% related documentation. +% - Development licenses grant access to the source code of the library +% to develop programs. These programs may be sold to other parties as +% executable code. To obtain a development license, please contact +% the GALIA Consortium (at cgal@cs.uu.nl). +% - Commercialization licenses grant access to the source code and the +% right to sell development licenses. To obtain a commercialization +% license, please contact the GALIA Consortium (at cgal@cs.uu.nl). +% +% This software and documentation is provided "as-is" and without +% warranty of any kind. In no event shall the CGAL Consortium be +% liable for any damage of any kind. +% +% The GALIA Consortium consists of Utrecht University (The Netherlands), +% ETH Zurich (Switzerland), Free University of Berlin (Germany), +% INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg +% (Germany), Max-Planck-Institute Saarbrucken (Germany), +% and Tel-Aviv University (Israel). +% +% ---------------------------------------------------------------------- +% +% package : Alpha_shapes_2 +% author(s) : Tran Kai Frank DA +% +% coordinator : INRIA Sophia-Antipolis () +% +% ====================================================================== + \RCSdef{\alphashapeRevision}{$Revision$} \RCSdefDate{\alphashapeDate}{$Date$} +%---------------------------------------------------------------------- + \chapter{Alpha-Shapes} \label{I1_ChapterAlphashapes} \ccChapterSubTitle{\alphashapeRevision, \alphashapeDate} @@ -8,8 +52,7 @@ \section{Introduction} This chapter presents a framework for alpha shapes. The description is based on -the articles \cite{em-tdas-94,e-was-92}. Alpha shapes can be used for shape -reconstruction from a dense unorganized set of data points. Alpha shapes are +the articles \cite{em-tdas-94,e-was-92}. Alpha shapes are the generalization of the convex hull of a point set. Let $S$ be a finite set of points in $\R^d$, $d = 2,3$ and $\alpha$ a parameter with $0 \leq \alpha \leq \infty$. For $\alpha = \infty$, the $\alpha$-shape is the convex hull of $S$. As @@ -17,14 +60,16 @@ $\alpha$ decreases, the $\alpha$-shape shrinks and develops cavities, as soon as a sphere of radius $\sqrt{\alpha}$ can be put inside. Finally, for $\alpha = 0$, the $\alpha$-shape is the set $S$ itself. -We can describe two versions of alpha shapes, one is based on the Delaunay +We distinguish two versions of alpha shapes, one is based on the Delaunay triangulation and the other on its generalization, the regular triangulation, replacing the natural distance by the power to weighted points. The metric used determines an underlying triangulation of the alpha shape and thus, the version computed. -In one hand, there is the classic alpha shapes associated with the Delaunay triangulations -(cf. \ref{I1_Sect_Delaunay}), in the other hand, the weighted alpha shapes -associated with the regular triangulations (cf. \ref{I1_Sect_Regular}). +In one hand, there is the {\em classic alpha shapes} +(cf. \ref{I1_SectClassicAS}) associated with the Delaunay triangulations +(cf. \ref{I1_Sect_Delaunay}), in the other hand, the {\em weighted alpha shapes} +(cf. \ref{I1_SectWeightedAS}) associated with the regular triangulations +(cf. \ref{I1_Sect_Regular}). There is a close connection between alpha shapes and the underlying triangulations. More precisely, the $\alpha$-complex of $S$ is a @@ -34,9 +79,7 @@ open disk (resp.\ ball) of radius $\sqrt{\alpha}$ through the vertices of the simplex that does not contain any other point of $S$, for the metric used in the computation of the underlying triangulation. The corresponding $\alpha$-shape is defined as the underlying interior space of the -$\alpha$-complex. The $\alpha$-shape is demarcated by a frontier, which is, -under conditions described in \cite{bb-srmua-97t}, a linear approximation of the -original contour. +$\alpha$-complex. In general, an $\alpha$-complex is a non-connected and non-pure polytope, it means, that one $k$-simplice, $0 \leq k \leq d-1$ is not necessary adjacent to @@ -44,7 +87,7 @@ a $(k+1)$-simplice. The $\alpha$-shapes of $S$ form a discrete family, even though they are defined for all real numbers $\alpha$ with $0 \leq \alpha -\leq \infty$. Thus, we can represent the entire family of $\alpha$ shapes +\leq \infty$. Thus, we can represent the entire family of $\alpha$-shapes of $S$ by the underlying triangulation of $S$. In this representation each $k$-simplex of the underlying triangulation is associated with an interval that specifies for which values of $\alpha$ the $k$-simplex @@ -54,6 +97,13 @@ easily. Furthermore, we can select an appropriate $\alpha$-shape from a finite number of different $\alpha$-shapes and corresponding $\alpha$-values. +\subsection*{Main Application} + +Alpha shapes can be used for shape reconstruction from a dense unorganized set +of data points. The $\alpha$-shape is demarcated by a frontier, which is, under +conditions described for the classic version in \cite{bb-srmua-97t}, a linear +approximation of the original contour. + %---------------------------------------------------------------------- \section{Generic Alpha-Shapes of Points in a Plane \label{I1_SectAlpha_Shape_2}} @@ -61,25 +111,25 @@ $\alpha$-values. \begin{ccClassTemplate} {Alpha_shape_2
} \ccDefinition + The class \ccClassTemplateName\ represents the family of $\alpha$-shapes of points in a plane for {\em all} positive -$\alpha$. It maintains the underlying triangulation \ccStyle{Dt} which +$\alpha$. It maintains the underlying triangulation \ccc{Dt} which represents connectivity and order among its faces. Each -$k$-dimensional face of the \ccStyle{Dt} is associated with +$k$-dimensional face of the \ccc{Dt} is associated with an interval that specifies for which values of $\alpha$ the face belongs to the $\alpha$-shape. There are links between the intervals and the $k$-dimensional faces of the triangulation. - \ccInclude{CGAL/Alpha_shape_2.h} \ccInheritsFrom -\ccStyle{Dt} +\ccc{Dt} This class is the underlying triangulation class. -The modifying functions \ccStyle{insert} and \ccStyle{remove} will overwrite +The modifying functions \ccc{insert} and \ccc{remove} will overwrite the inherited functions. At the moment, only the static version is implemented. \ccTypes @@ -87,24 +137,24 @@ the inherited functions. At the moment, only the static version is implemented. \ccThreeToTwo \ccNestedType{Gt}{the alpha shape traits type.} -it contains a Delaunay triangulation traits class. For example \ccStyle{Dt::Point} is a Point class. +it contains a Delaunay triangulation traits class. For example \ccc{Dt::Point} is a Point class. \ccTypedef{typedef Gt::Coord_type Coord_type;}{the number type for computation.} \ccNestedType{Alpha_iterator}{An iterator that allow to traverse the increasing sequence of different $\alpha$-values. The iterator is -bidirectional and non-mutable. Its \ccStyle{value_type} -is \ccStyle{Coord_type}} +bidirectional and non-mutable. Its \ccc{value_type} +is \ccc{Coord_type}} \ccEnum{enum Classification_type {EXTERIOR, SINGULAR, REGULAR, INTERIOR};} {Distinguishes the different cases for classifying a $k$-dimensional face of the underlying triangulation of the $\alpha$-shape. \\ -\ccStyle{EXTERIOR} if the face does not belong to the $\alpha$-complex.\\ -\ccStyle{SINGULAR} if the face belongs to the boundary of the $\alpha$-shape, +\ccc{EXTERIOR} if the face does not belong to the $\alpha$-complex.\\ +\ccc{SINGULAR} if the face belongs to the boundary of the $\alpha$-shape, but is not incident to any 2-dimensional face of the $\alpha$-complex\\ -\ccStyle{REGULAR} if the face belongs to the boundary of the $\alpha$-shape +\ccc{REGULAR} if the face belongs to the boundary of the $\alpha$-shape and is incident to a 2-dimensional face of the $\alpha$-complex\\ -\ccStyle{INTERIOR} if the face belongs to the $\alpha$-complex, but does +\ccc{INTERIOR} if the face belongs to the $\alpha$-complex, but does not belong to the boundary of the $\alpha$-shape\\} \ccEnum{enum Mode {GENERAL, REGULARIZED};} @@ -118,8 +168,8 @@ and their vertices} \ccConstructor{Alpha_shape_2(Coord_type alpha = 0, Mode m = GENERAL);} {Introduces an empty $\alpha$-shape \ccVar\ for a positive $\alpha$-value - \ccStyle{alpha}. -\ccPrecond \ccStyle{alpha}~$\geq~0$.} + \ccc{alpha}. +\ccPrecond \ccc{alpha}~$\geq~0$.} \ccConstructor{template < class InputIterator > @@ -129,12 +179,12 @@ and their vertices} const Coord_type& alpha = 0, Mode m = GENERAL);} {Initializes the family of alpha-shapes with the points in the range -$\left[\right.$\ccStyle{first}, \ccStyle{last}$\left.\right)$ and +$\left[\right.$\ccc{first}, \ccc{last}$\left.\right)$ and introduces an $\alpha$-shape \ccVar\ for a positive $\alpha$-value -\ccStyle{alpha}. -\ccPrecond The \ccStyle{value_type} of \ccStyle{first} and -\ccStyle{last} is \ccStyle{Point}.\\ -\ccStyle{alpha} $\geq 0$.} +\ccc{alpha}. +\ccPrecond The \ccc{value_type} of \ccc{first} and +\ccc{last} is \ccc{Point}.\\ +\ccc{alpha} $\geq 0$.} \ccOperations @@ -145,14 +195,14 @@ introduces an $\alpha$-shape \ccVar\ for a positive $\alpha$-value const Coord_type& alpha = 0, Mode m = GENERAL);} {Initialize the family of alpha-shapes with the points in the range -$\left[\right.$\ccStyle{first}, \ccStyle{last}$\left.\right)$ and +$\left[\right.$\ccc{first}, \ccc{last}$\left.\right)$ and introduces an $\alpha$-shape \ccVar\ for a positive $\alpha$-value -\ccStyle{alpha}. Returns the number of inserted points. \\ +\ccc{alpha}. Returns the number of inserted points. \\ If the function is applied to an non-empty family of alpha-shape, it is cleared before initialization. -\ccPrecond The \ccStyle{value_type} of \ccStyle{first} and -\ccStyle{last} is \ccStyle{Point}.\\ -\ccStyle{alpha} $\geq 0$.} +\ccPrecond The \ccc{value_type} of \ccc{first} and +\ccc{last} is \ccc{Point}.\\ +\ccc{alpha} $\geq 0$.} \ccMethod{void clear();} @@ -160,9 +210,9 @@ before initialization. \ccMethod{Coord_type set_alpha(const Coord_type& alpha);} -{Sets the $\alpha$-value to \ccStyle{alpha}. +{Sets the $\alpha$-value to \ccc{alpha}. Returns the previous $\alpha$-value. -\ccPrecond \ccStyle{alpha} $\geq 0$.} +\ccPrecond \ccc{alpha} $\geq 0$.} \ccMethod{const Coord_type& get_alpha(void) const;} @@ -170,7 +220,7 @@ before initialization. \ccMethod{const Coord_type& get_nth_alpha(int n) const;} {Returns the $n$-th alpha-value, sorted in an increasing order. - \ccPrecond \ccStyle{n} < number of alphas.} + \ccPrecond \ccc{n} < number of alphas.} \ccMethod{int number_of_alphas() const;} {Returns the number of different alpha-values.} @@ -178,9 +228,9 @@ before initialization. % dynamic version % % \ccMethod{Vertex_handle insert(const Point& p);} -% {Inserts point \ccStyle{p} in the alpha shape and returns the +% {Inserts point \ccc{p} in the alpha shape and returns the % corresponding vertex of the underlying Delaunay triangulation.\\ If -% point \ccStyle{p} coincides with an already existing vertex, this +% point \ccc{p} coincides with an already existing vertex, this % vertex is returned and the alpha shape remains unchanged.\\ Otherwise, % the vertex is inserted in the underlying Delaunay triangulation and % the associated intervals are updated. } @@ -204,8 +254,8 @@ Returns the previous mode.} OutputIterator get_alpha_shape_vertices( OutputIterator result);} {Writes the vertices of the alpha shape \ccVar\ for the current $\alpha$-value -to the container where \ccStyle{result} refers to. -The \ccStyle{value_type} of \ccStyle{result} is \ccStyle{Vertex_handle}. +to the container where \ccc{result} refers to. +The \ccc{value_type} of \ccc{result} is \ccc{Vertex_handle}. Returns an output iterator which is the end of the constructed range.} \ccMethod{template < class OutputIterator > @@ -213,8 +263,8 @@ Returns an output iterator which is the end of the constructed range.} OutputIterator result);} {Writes the edges of the alpha shape \ccVar\ for the current $\alpha$-value -to the container where \ccStyle{result} refers to. -The \ccStyle{value_type} of \ccStyle{result} is \ccStyle{pair}. +to the container where \ccc{result} refers to. +The \ccc{value_type} of \ccc{result} is \ccc{pair}. Returns an output iterator which is the end of the constructed range.} \ccHeading{Predicates} @@ -223,26 +273,26 @@ Returns an output iterator which is the end of the constructed range.} \ccMethod{Classification_type classify(const Point& p, const Coord_type& alpha = get_alpha()) const;} -{Locates a point \ccStyle{p} in the underlying triangulation and Classifies the +{Locates a point \ccc{p} in the underlying triangulation and Classifies the associated k-face with respect to \ccVar.} \ccMethod{Classification_type classify(Face_handle f, const Coord_type& alpha = get_alpha()) const;} -{Classifies the face \ccStyle{f} of the underlying triangulation with respect to \ccVar.} +{Classifies the face \ccc{f} of the underlying triangulation with respect to \ccVar.} \ccMethod{Classification_type classify(pair e, const Coord_type& alpha = get_alpha()) const;} -{Classifies the edge \ccStyle{e} of the underlying triangulation with respect to \ccVar.} +{Classifies the edge \ccc{e} of the underlying triangulation with respect to \ccVar.} \ccMethod{Classification_type classify(Face_handle f, int i, const Coord_type& alpha = get_alpha()) const;} -{Classifies the edge of the face \ccStyle{f} opposite to the vertex with index -\ccStyle{i} +{Classifies the edge of the face \ccc{f} opposite to the vertex with index +\ccc{i} of the underlying triangulation with respect to \ccVar.} \ccMethod{Classification_type classify(Vertex_handle v, const Coord_type& alpha = get_alpha()) const;} -{Classifies the vertex \ccStyle{v} of the underlying triangulation with respect to \ccVar.} +{Classifies the vertex \ccc{v} of the underlying triangulation with respect to \ccVar.} \ccHeading{Traversal of the $\alpha$-Values} @@ -251,7 +301,7 @@ of the underlying triangulation with respect to \ccVar.} The alpha shape class defines an iterator that allows to visit the sorted sequence of $\alpha$-values. This iterator is non-mutable and bidirectional. Its value type is -\ccStyle{Coord_type}. +\ccc{Coord_type}. \ccMethod{Alpha_iterator alpha_begin() const;} {Returns an iterator that allows to traverse the @@ -262,16 +312,16 @@ sorted sequence of $\alpha$-values of the family of alpha shapes.} \ccMethod{Alpha_iterator alpha_find(const Coord_type& alpha) const;} {Returns an iterator pointing to an element with $\alpha$-value -\ccStyle{alpha}, or the corresponding past-the-end iterator if such +\ccc{alpha}, or the corresponding past-the-end iterator if such an element is not found.} \ccMethod{Alpha_iterator alpha_lower_bound(const Coord_type& alpha) const;} {Returns an iterator pointing to the first element with -$\alpha$-value not less than \ccStyle{alpha}.} +$\alpha$-value not less than \ccc{alpha}.} \ccMethod{Alpha_iterator alpha_upper_bound(const Coord_type& alpha) const;} {Returns an iterator pointing to the first element with $\alpha$-value -greater than \ccStyle{alpha}.} +greater than \ccc{alpha}.} \ccHeading{Operations} @@ -283,14 +333,14 @@ regularized version.} \ccMethod{Alpha_iterator find_optimal_alpha(int nb_components) const;} {Returns an iterator pointing to the first element with $\alpha$-value such that \ccVar\ satisfies the following two properties:\\ -\ccStyle{nb_components} equals the number of solid components and \\ +\ccc{nb_components} equals the number of solid components and \\ all data points are either on the boundary or in the interior of the regularized version of \ccVar.\\ If no such value is found, the iterator points to the first element with $\alpha$-value such that \ccVar\ satisfies the second property.} \ccHeading{I/O} -The I/O operators are defined for \ccStyle{iostream}, and for +The I/O operators are defined for \ccc{iostream}, and for the window stream provided by \cgal. The format for the iostream is an internal format. @@ -298,8 +348,8 @@ is an internal format. \ccFunction{ostream& operator<<(ostream& os, const Alpha_shape_2
& A);} -{Inserts the alpha shape \ccVar\ for the current $\alpha$-value into the stream \ccStyle{os}. -\ccPrecond The insert operator must be defined for \ccStyle{Point}.} +{Inserts the alpha shape \ccVar\ for the current $\alpha$-value into the stream \ccc{os}. +\ccPrecond The insert operator must be defined for \ccc{Point}.} \ccInclude{CGAL/IO/Window_stream.h} @@ -307,16 +357,16 @@ is an internal format. \ccFunction{Window_stream& operator<<(Window_stream& W, const Alpha_shape_2
& A);} -{Inserts the alpha shape \ccVar\ for the current $\alpha$-value into the window stream \ccStyle{W}. -\ccPrecond The insert operator must be defined for \ccStyle{Point} and \ccStyle{Segment}.} +{Inserts the alpha shape \ccVar\ for the current $\alpha$-value into the window stream \ccc{W}. +\ccPrecond The insert operator must be defined for \ccc{Point} and \ccc{Segment}.} \end{ccClassTemplate} \ccImplementation In the first static version, the set of intervals associated with the $k$-dimensional faces of the underlying triangulation are -stored only as sorted \ccStyle{vectors}. By using an interval tree the +stored only as sorted \ccc{vectors}. By using an interval tree the alpha-shape could be constructed more efficiently. For the dynamic -version, we need \ccStyle{multimaps} or dynamic interval trees. +version, we need \ccc{multimaps} or dynamic interval trees. The cross links between the intervals and the $k$-dimensional faces of the triangulation are actually realized using methods in the $k$-dimensional faces @@ -324,43 +374,46 @@ themselves. By this way, you can decide if you want to store or re-compute any of these informations. -\ccStyle{A.alpha find} uses linear search, while -\ccStyle{A.alpha lower bound} and \ccStyle{A.alpha upper bound} +\ccc{A.alpha find} uses linear search, while +\ccc{A.alpha lower bound} and \ccc{A.alpha upper bound} use binary search. -\ccStyle{A.number solid components} performs a graph traversal and takes time +\ccc{A.number solid components} performs a graph traversal and takes time linear in the number of faces of the underlying triangulation. -\ccStyle{A.find optimal alpha} uses binary search and takes time +\ccc{A.find optimal alpha} uses binary search and takes time $O(\mbox{ \em n } \log{\mbox{ \em n } })$, where $n$ is the number of points. %---------------------------------------------------------------------- \section{The Underlying Triangulation\label{I1_SectDtClass}} -The class \ccStyle{Dt} must be parameterized with a special alpha shape -traits class and a triangulation data structure, with no more requirements as +For the \ccc{Dt} class, you have to choose between a Delaunay or a regular +triangulation, depending the version of alpha shapes, you want. + +The class \ccc{Dt} must be parameterized with a special alpha shape +traits class and a simple triangulation data structure, with no more requirements as for a simple triangulation class, but parameterized by a special vertex base class and a special face base class. -\section*{The Alpha-Shape Traits Class\label{I1_ASTraits}} +\section*{The Alpha-Shape Traits Class (\mbox{\it Gt})\label{I1_ASTraits}} \subsection{Requirements for the Alpha-Shape Traits Class} First, this traits class has the same requirements as the -triangulation traits class, for the \ccStyle{Dt} triangulation, you choose. +triangulation traits class, for the \ccc{Dt} triangulation, you opted. The following requirement catalog lists the primitives that must be defined additionally. \begin{ccClass} {Gt} -\subsection*{Alpha Shape Traits (\mbox{\it Gt})} +\subsection*{\protect \ccc{Alpha_shape_traits} (\mbox{\it Gt})} \ccCreationVariable{t} \ccDefinition -A class \ccClassName\ that satisfies the requirements of a alpha shape -traits class must provide the following predicate and operations in -addition to the requirements for the Delaunay triangulation traits -class. +A class \ccClassName\ that satisfies the requirements of a +\ccc{Alpha_shape_traits} class must provide the following predicate and +operations in addition to the requirements for the underlying triangulation +traits class. \ccTypes @@ -368,15 +421,9 @@ class. The type must provide a copy constructor, assignment, comparison operators, negation, multiplication, division and allow the declaration and initialization with a small integer constant -(cf. requirements for number types). An obvious choice would be -coordinate type of the point class.} +(cf. requirements for number types). +\ccPrecond An obvious choice would be coordinate type of the point class.} -\ccNestedType{Coord_type}{A type to hold a coordinate type class. -The type must provide a copy constructor, assignment, comparison -operators, negation, multiplication, division and allow the -declaration and initialization with a small integer constant -(cf. requirements for number types). An obvious choice would be -coordinate type of the point class.} \ccCreation Only a default constructor is required. Note that further constructors @@ -391,30 +438,30 @@ can be provided. const Point& p1, const Point& p2) const;} {Returns the squared radius of the circle of the -points \ccStyle{p0, p1, p2}, associated with the metric -used by \ccStyle{Dt}.} +points \ccc{p0, p1, p2}, associated with the metric +used by \ccc{Dt}.} \ccMethod{Coord_type squared_radius(const Point& p0, const Point& p1) const;} {Returns the squared radius of smallest circle of the -points \ccStyle{p0, p1}, associated with the metric -used by \ccStyle{Dt}.} +points \ccc{p0, p1}, associated with the metric +used by \ccc{Dt}.} \ccHeading{Predicate} \ccMethod{Bounded_side side_of_circle(const Point& p0, const Point& p1, const Point& test) const;} -{Returns the relative position of point \ccStyle{test} to the smallest circle of -the points \ccStyle{p0, p1}, using the same metric as \ccStyle{Dt}.} +{Returns the relative position of point \ccc{test} to the smallest circle of +the points \ccc{p0, p1}, using the same metric as \ccc{Dt}.} \end{ccClass} -\section*{Triangulation Data Structure Class for an Alpha-Shape} +\section*{Triangulation Data Structure Class (\mbox{\it Tds}) for an Alpha-Shape} -The class \ccStyle{Alpha_shape_2
} parameterized with a -triangulation data structure class \ccStyle{Tds}, that has exactly the same +The class \ccc{Alpha_shape_2
} parameterized with a +triangulation data structure class \ccc{Tds}, that has exactly the same requirements as the triangulation data structure class for a simple triangulation. @@ -428,7 +475,7 @@ Alpha-Shape\label{I1_SectVertex}} The information about the alpha values associated are accessible by the vertices of the alpha shape. Thus the nested \ccc{Alpha_shape_vertex_base} -type of a alpha shape offers additional functionalities to deal with these +type of an alpha shape offers additional functionalities to deal with these methods. This additional functionalities related to the Alpha Shape @@ -439,7 +486,7 @@ They are listed below as such. \ccInheritsFrom -\ccStyle{Triangulation_vertex_base} +\ccc{Triangulation_vertex_base} \begin{ccClass}{Alpha_shape_vertex_base} @@ -453,8 +500,8 @@ operators, negation, multiplication, division and allow the declaration and initialization with a small integer constant (cf. requirements for number types). An obvious choice would be coordinate type of the point class. -\ccPrecond Let's us precise that \ccStyle{Coord_type} has to be the same as the one used by -the \ccStyle{Gt}, already used by underlying triangulation \ccStyle{Dt}.} +\ccPrecond Let's us precise that \ccc{Coord_type} has to be the same as the one used by +the \ccc{Gt}, already used by underlying triangulation \ccc{Dt}.} \ccCreation @@ -496,27 +543,27 @@ for $\alpha$ under $\alpha_1$, the vertex is regular.} The information about the alpha values, associated to the face herself and the incident edges, are accessible by the faces of the alpha shape. Thus the nested \ccc{Alpha_shape_face_base} -type of a alpha shape offers additional functionalities to deal with these +type of an alpha shape offers additional functionalities to deal with these methods. -\ccStyle{Df} has to be choosed as the face base for the underlying triangulation. +\ccc{Df} has to be choosed as the face base for the underlying triangulation. This additional functionalities related to the alpha shape are requirements which have to be fulfilled by the base face for an alpha shape, -in addition to the functionalities required by an underlying triangulation face \ccStyle{Df}. +in addition to the functionalities required by an underlying triangulation face \ccc{Df}. They are listed below as such. \ccInheritsFrom -\ccStyle{Df} +\ccc{Df} \begin{ccClass}{Alpha_shape_face_base} \ccCreationVariable{f} \ccTypes -\ccNestedType{Interval_3}{A container to get (and put) the three special values +\ccNestedType{Interval_3}{A container type to get (and put) the three special values ($\alpha_1, \alpha_2, \alpha_3$) associated with an alpha shape edge.} \ccNestedType{Coord_type}{A type to hold a coordinate type class. @@ -525,9 +572,9 @@ operators, negation, multiplication, division and allow the declaration and initialization with a small integer constant (cf. requirements for number types). An obvious choice would be coordinate type of the point class. -\ccPrecond Let's us precise that \ccStyle{Coord_type} has to be the same as the one used by -\ccStyle{Gt}, already used by the underlying triangulation \ccStyle{Dt}, and by -her face base \ccStyle{Df}.} +\ccPrecond Let's us precise that \ccc{Coord_type} has to be the same as the one used by +\ccc{Gt}, already used by the underlying triangulation \ccc{Dt}, and by +her face base \ccc{Df}.} \ccCreation @@ -575,18 +622,18 @@ face.} %---------------------------------------------------------------------- -\section{Classic Version of Alpha-Shape} +\section{Classic Version of Alpha-Shape\label{I1_SectClassicAS}} \subsection*{The Underlying Triangulation~: a Delaunay Triangulation} For a simple alpha shape, you have to choose a Delaunay triangulation as -underlying triangulation \ccStyle{Dt} and follow the requirements listed above. +underlying triangulation \ccc{Dt} and follow the requirements listed above. \ccInclude{CGAL/Delaunay_triangulation_2.h} -\subsection*{Predefined Geometric Traits Class} +\subsection*{Predefined Geometric Traits Class (\mbox{\it Gt})} -Of course, \cgal\ provides a default \ccc{Alpha_shape_traits} class in this +Of course, \cgal\ provides a default \ccc{Alpha_shape_traits} class in this case, with an implementation of the appropriate predicate and constructions. The class \ccc{Alpha_shape_euclidean_traits_2} simply derived from \ccc{Triangulation_euclidean_traits_2}. @@ -632,18 +679,18 @@ typedef CGAL::Alpha_shape_2
Alpha_shape_2; %---------------------------------------------------------------------- -\section{Weighted Version of Alpha-Shape} +\section{Weighted Version of Alpha-Shape\label{I1_SectWeightedAS}} \subsection*{The Underlying Triangulation~: a Regular Triangulation} For a weighted alpha shape, you have to choose a regular triangulation as -underlying triangulation \ccStyle{Dt} and follow the requirements listed above. +underlying triangulation \ccc{Dt} and follow the requirements listed above. \ccInclude{CGAL/Regular_triangulation_2.h} -\subsection*{Predefined Geometric Traits Class} +\subsection*{Predefined Geometric Traits Class (\mbox{\it Gt})} -Of course, \cgal\ provides a default \ccc{Alpha_shape_traits} class in this +Of course, \cgal\ provides a default \ccc{Alpha_shape_traits} class in this case, with an implementation of the appropriate predicate and constructions. The class \ccc{Weighted_alpha_shape_euclidean_traits_2} simply derived from \ccc{Regular_euclidean_traits_2}. @@ -686,76 +733,3 @@ typedef CGAL::Triangulation_default_data_structure_2 Tds; typedef CGAL::Regular_triangulation_2 Rt; typedef CGAL::Alpha_shape_2 Alpha_shape_2; \end{cprog} - -%---------------------------------------------------------------------- - -\section{Additional Functionalities for Weighted Alpha-Shape\label{I2_SectWeighted_Alpha_Shape_2}} - -\begin{ccClassTemplate} {Weighted_alpha_shape_2} - -\ccDefinition -Specially for the weighted version, the computation of alpha shape often -enforces an estimation of weights for the sample of points. This class -\ccClassTemplateName\ provides some heuristic methods to initialize these -weights in two dimensions. They can deal with samples of points extract from a -contour in a plane. The main idea is to control an union of sphere, dual of the -weighted alpha shape, which has to preserve the skeleton of the original -contour. The best results are in \ccc{GENERAL} mode, with $\alpha=0$. - -\ccInclude{CGAL/Weighted_alpha_shape_2.h} - -\ccInheritsFrom - -\ccStyle{Alpha_shape_2} - -This\ccClassTemplateName\ has exactly the same requirements as the -\ccc{Alpha_shape_2} class, used for the weighted version of alpha shape. - -\ccCreation -\ccCreationVariable{A} - -\ccConstructor{Weighted_alpha_shape_2(Coord_type alpha = 0, - Mode m = GENERAL);} -{Introduces an empty $\alpha$-shape \ccVar\ for a positive $\alpha$-value - \ccStyle{alpha}. -\ccPrecond \ccStyle{alpha}~$\geq~0$.} - - -\ccConstructor{template < class InputIterator > - Weighted_alpha_shape_2( - InputIterator first, - InputIterator last, - const Coord_type& alpha = 0, - Mode m = GENERAL);} -{Initializes the family of alpha-shapes with the weighted points in the range -$\left[\right.$\ccStyle{first}, \ccStyle{last}$\left.\right)$ and -introduces an $\alpha$-shape \ccVar\ for a positive $\alpha$-value -\ccStyle{alpha}. -\ccPrecond The \ccStyle{value_type} of \ccStyle{first} and -\ccStyle{last} is \ccStyle{Weighted_point}.\\ -\ccStyle{alpha} $\geq 0$.} - -\ccOperations - -\ccMethod{template < class Iterator > -void -initialize_weights_to_the_nearest_voronoi_vertex -(Iterator first, Iterator last, const Coord_type& k);} -{initialize the weight of each point, stored in a container of points, with a value -equal to the distance to his nearest Voronoi vertex multiply by $k \leq 1$.} - -\ccMethod{template < class Iterator > -void -initialize_weights_to_the_nearest_voronoi_edge -(Iterator first, Iterator last, const Coord_type& k);} -{initialize the weight of each point, stored in a container of points, with a -value equal to the distance to his nearest Voronoi edge multiply by $k \geq 1$.} - -\ccMethod{template < class Iterator > -void -initialize_weights_to_the_nearest_vertex -(Iterator first, Iterator last, const Coord_type& k);} -{initialize the weight of each point, stored in a container of points, with a -value equal to the distance to his nearest vertex multiply by $k$.} - -\end{ccClassTemplate} diff --git a/Packages/Alpha_shapes_2/version b/Packages/Alpha_shapes_2/version index ab7217a7377..a5c2e345ff3 100644 --- a/Packages/Alpha_shapes_2/version +++ b/Packages/Alpha_shapes_2/version @@ -1 +1 @@ -2.3 ( 9 Nov 1999) +2.4 (15 Nov 1999)