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

made a base class for Vertex_data and changed templating of other 

internal classes to make sharing of code with polygon generator possible
This commit is contained in:
Susan Hert 2001-10-30 09:38:50 +00:00
parent 44c9569566
commit 31b2fb6297
2 changed files with 69 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
Packages/Polygon/changes.txt
View File

@ -1,3 +1,10 @@
4.5 (30 October 2001)
+ Susan made a base class for Vertex_data so it can be shared with the
Vertex_data used in generating random polygons (Generator package)
+ Susan changed template parameters of some internal class to make
code sharing easier
+ Susan made traits classes passed by const-ref
4.4 (21 September 2001)
+ Fixed a bug in the simplicity test.

104
Packages/Polygon/include/CGAL/Polygon_2_simplicity.h
View File

@ -8,7 +8,7 @@
//
// ----------------------------------------------------------------------
//
// release :
// release :
// release_date :
//
// file : include/CGAL/Polygon_2_simplicity.h
@ -91,13 +91,13 @@ private:
template <class ForwardIterator, class PolygonTraits>
class Vertex_data ;
template <class ForwardIterator, class PolygonTraits>
template <class VertexData>
class Less_segments {
Vertex_data<ForwardIterator, PolygonTraits> *m_vertex_data;
typedef VertexData Vertex_data;
Vertex_data *m_vertex_data;
bool less_than_in_tree(Vertex_index i, Vertex_index j);
public:
Less_segments(Vertex_data<ForwardIterator, PolygonTraits> *vertex_data)
: m_vertex_data(vertex_data) {}
Less_segments(Vertex_data *vertex_data) : m_vertex_data(vertex_data) {}
bool operator()(Vertex_index i, Vertex_index j);
};
@ -106,10 +106,9 @@ class Less_segments {
// Although conceptually this data belongs in the tree, it is stored with
// the vertices in the Vertex_data structure.
template <class ForwardIterator, class PolygonTraits>
template <class LessSegments>
struct Edge_data {
typedef std::set<Vertex_index,
Less_segments<ForwardIterator,PolygonTraits> > Tree;
typedef std::set<Vertex_index, LessSegments> Tree;
Edge_data() : is_in_tree(false) {}
typename Tree::iterator tree_it; // The iterator of the edge in the tree.
// Needed for cross reference. If edge j
@ -121,23 +120,22 @@ struct Edge_data {
};
template <class ForwardIterator, class PolygonTraits>
class Vertex_data {
class Vertex_data_base {
public:
typedef std::set<Vertex_index,
Less_segments<ForwardIterator,PolygonTraits> > Tree;
typedef typename PolygonTraits::Point_2 Point_2;
typedef typename PolygonTraits::Point_2 Point_2;
Vertex_data(ForwardIterator begin, ForwardIterator end,PolygonTraits pgnt);
// ForwardIterator points_start;
std::vector<ForwardIterator> iterators;
std::vector<Vertex_order> m_order_of;
std::vector<Vertex_index> m_idx_at_rank;
std::vector<Edge_data<ForwardIterator, PolygonTraits> > edges;
std::vector<Vertex_index>::size_type m_size;
typename PolygonTraits::Orientation_2 orientation_2;
typename PolygonTraits::Less_xy_2 less_xy_2;
bool is_simple_result;
Vertex_data_base(ForwardIterator begin, ForwardIterator end,
const PolygonTraits& pgnt);
bool ordered_left_to_right(Vertex_index v1, Vertex_index v2)
{ return m_order_of[v1.as_int()].as_int() <
m_order_of[v2.as_int()].as_int();}
@ -150,13 +148,28 @@ public:
? Vertex_index(m_size-1)
: Vertex_index(k.as_int()-1);
}
Point_2 point(Vertex_index i)
{ return *iterators[i.as_int()];}
// { return points_start[i.as_int()];}
};
template <class ForwardIterator, class PolygonTraits>
class Vertex_data : public Vertex_data_base<ForwardIterator, PolygonTraits> {
public:
typedef Less_segments<Vertex_data> Less_segs;
typedef std::set<Vertex_index, Less_segs> Tree;
typedef Vertex_data_base<ForwardIterator, PolygonTraits> Base_class;
std::vector<Edge_data<Less_segs> > edges;
Vertex_data(ForwardIterator begin, ForwardIterator end,
const PolygonTraits& pgnt);
void left_and_right_index(Vertex_index &left, Vertex_index &right,
Vertex_index edge);
Vertex_index left_index(Vertex_index edge)
{ return edges[edge.as_int()].is_left_to_right ? edge : next(edge); }
Point_2 point(Vertex_index i)
// { return points_start[i.as_int()];}
{ return *iterators[i.as_int()];}
void sweep(Tree *tree);
bool insertion_event(Tree *tree,
Vertex_index i, Vertex_index j, Vertex_index k);
@ -166,11 +179,11 @@ public:
bool on_right_side(Vertex_index vt, Vertex_index edge, bool above);
};
template <class ForwardIterator, class PolygonTraits>
template <class VertexData>
class Less_vertex_data {
Vertex_data<ForwardIterator, PolygonTraits> *m_vertex_data;
VertexData *m_vertex_data;
public:
Less_vertex_data(Vertex_data<ForwardIterator, PolygonTraits> *vd)
Less_vertex_data(VertexData *vd)
: m_vertex_data(vd) {}
bool operator()(Vertex_index i, Vertex_index j);
};
@ -180,8 +193,8 @@ public:
// ----- implementation of i_polygon functions. -----
namespace i_polygon {
template <class ForwardIterator, class PolygonTraits>
bool Less_segments<ForwardIterator, PolygonTraits>::
template <class VertexData>
bool Less_segments<VertexData>::
operator()(Vertex_index i, Vertex_index j)
{
if (m_vertex_data->edges[j.as_int()].is_in_tree) {
@ -191,8 +204,8 @@ operator()(Vertex_index i, Vertex_index j)
}
}
template <class ForwardIterator, class PolygonTraits>
bool Less_segments<ForwardIterator, PolygonTraits>::
template <class VertexData>
bool Less_segments<VertexData>::
less_than_in_tree(Vertex_index new_edge, Vertex_index tree_edge)
{
CGAL_polygon_precondition(
@ -215,8 +228,8 @@ less_than_in_tree(Vertex_index new_edge, Vertex_index tree_edge)
return true;
}
template <class ForwardIterator, class PolygonTraits>
bool Less_vertex_data<ForwardIterator, PolygonTraits>::
template <class VertexData>
bool Less_vertex_data<VertexData>::
operator()(Vertex_index i, Vertex_index j)
{
return m_vertex_data->less_xy_2(
@ -224,11 +237,10 @@ operator()(Vertex_index i, Vertex_index j)
}
template <class ForwardIterator, class PolygonTraits>
Vertex_data<ForwardIterator, PolygonTraits>::
Vertex_data(ForwardIterator begin, ForwardIterator end,
PolygonTraits pgn_traits)
: // points_start(begin),
orientation_2(pgn_traits.orientation_2_object()),
Vertex_data_base<ForwardIterator, PolygonTraits>::
Vertex_data_base(ForwardIterator begin, ForwardIterator end,
const PolygonTraits& pgn_traits)
: orientation_2(pgn_traits.orientation_2_object()),
less_xy_2(pgn_traits.less_xy_2_object())
{
m_size = std::distance(begin, end);
@ -236,14 +248,12 @@ Vertex_data(ForwardIterator begin, ForwardIterator end,
m_idx_at_rank.reserve(m_size);
iterators.reserve(m_size);
m_order_of.insert(m_order_of.end(), m_size, Vertex_order(0));
edges.insert(edges.end(), m_size,
Edge_data<ForwardIterator, PolygonTraits>());
for (Index_t i = 0; i< m_size; ++i, ++begin) {
m_idx_at_rank.push_back(Vertex_index(i));
iterators.push_back(begin);
}
std::sort(m_idx_at_rank.begin(), m_idx_at_rank.end(),
Less_vertex_data<ForwardIterator, PolygonTraits>(this));
Less_vertex_data<Vertex_data_base>(this));
for (Index_t j = 0; j < m_size; ++j) {
Vertex_order vo(j);
m_order_of[index_at_rank(vo).as_int()] = vo;
@ -262,6 +272,16 @@ left_and_right_index(Vertex_index &left, Vertex_index &right,
}
}
template <class ForwardIterator, class PolygonTraits>
Vertex_data<ForwardIterator, PolygonTraits>::
Vertex_data(ForwardIterator begin, ForwardIterator end,
const PolygonTraits& pgn_traits)
: Base_class(begin, end, pgn_traits)
{
edges.insert(edges.end(), m_size, Edge_data<Less_segs>());
}
template <class ForwardIterator, class PolygonTraits>
bool Vertex_data<ForwardIterator, PolygonTraits>::
insertion_event(Tree *tree, Vertex_index prev_vt,
@ -275,7 +295,7 @@ insertion_event(Tree *tree, Vertex_index prev_vt,
case COLLINEAR: return false;
}
Edge_data<ForwardIterator, PolygonTraits>
Edge_data<Less_segs>
&td_prev = edges[prev_vt.as_int()],
&td_mid = edges[mid_vt.as_int()];
td_prev.is_in_tree = false;
@ -331,7 +351,7 @@ replacement_event(Tree *tree, Vertex_index cur_edge, Vertex_index next_edge)
{
// check if continuation point is on the right side of neighbor segments
typedef typename Tree::iterator It;
Edge_data<ForwardIterator, PolygonTraits> &td = edges[cur_edge.as_int()];
Edge_data<Less_segs> &td = edges[cur_edge.as_int()];
CGAL_polygon_assertion(td.is_in_tree);
It cur_seg = td.tree_it;
Vertex_index cur_vt = (td.is_left_to_right) ? next_edge : cur_edge;
@ -350,7 +370,7 @@ replacement_event(Tree *tree, Vertex_index cur_edge, Vertex_index next_edge)
}
}
// replace the segment
Edge_data<ForwardIterator, PolygonTraits> &new_td =
Edge_data<Less_segs> &new_td =
edges[next_edge.as_int()];
new_td.is_left_to_right = td.is_left_to_right;
new_td.is_in_tree = false;
@ -367,7 +387,7 @@ deletion_event(Tree *tree, Vertex_index prev_vt, Vertex_index mid_vt)
{
// check if continuation point is on the right side of neighbor segments
typedef typename Tree::iterator It;
Edge_data<ForwardIterator, PolygonTraits>
Edge_data<Less_segs>
&td_prev = edges[prev_vt.as_int()],
&td_mid = edges[mid_vt.as_int()];
It prev_seg = td_prev.tree_it, mid_seg = td_mid.tree_it;
@ -434,13 +454,13 @@ sweep(Tree *tree)
template <class Iterator, class PolygonTraits>
bool is_simple_polygon(Iterator points_begin, Iterator points_end,
PolygonTraits polygon_traits)
const PolygonTraits& polygon_traits)
{
typedef Iterator ForwardIterator;
typedef i_polygon::Vertex_data<ForwardIterator, PolygonTraits> Vertex_data;
typedef std::set<i_polygon::Vertex_index,
i_polygon::Less_segments<ForwardIterator,PolygonTraits> > Tree;
i_polygon::Vertex_data<ForwardIterator, PolygonTraits>
vertex_data(points_begin, points_end, polygon_traits);
i_polygon::Less_segments<Vertex_data> > Tree;
Vertex_data vertex_data(points_begin, points_end, polygon_traits);
Tree tree(&vertex_data);
vertex_data.sweep(&tree);
return vertex_data.is_simple_result;