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

631 lines
21 KiB
C++
Raw Blame History

// Copyright (c) 2005 Tel-Aviv University (Israel).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org); you may redistribute it under
// the terms of the Q Public License version 1.0.
// See the file LICENSE.QPL distributed with CGAL.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// $URL$
// $Id$
//
//
// Author(s) : Michal Meyerovitch <gorgymic@post.tau.ac.il>
#ifndef CGAL_ENVELOPE_ARRANGEMENT_ZONE_2_H
#define CGAL_ENVELOPE_ARRANGEMENT_ZONE_2_H
/*! \file
* Defintion of the Envelope_arrangement_zone_2 class.
*/
#include <CGAL/Arrangement_zone_2.h>
#include <CGAL/Arr_observer.h>
#include <list>
#include <map>
#include <set>
CGAL_BEGIN_NAMESPACE
/*! \class
* A class for computing the zone of a given $x$-monotone curve in a given
* arrangement.
* The arrangement parameter corresponds to the underlying arrangement, and
* the zone-visitor parameter corresponds to a visitor class which is capable
* of receiving notifications on the arrangment features the query curve
* traverses. The visitor has to support the following functions:
* - init(), for initializing the visitor with a given arrangement.
* - found_subcurve(), called when a non-intersecting x-monotone curve is
* computed and located in the arrangement.
* - found_overlap(), called when an x-monotone curve overlaps an existing
* halfedge in the arrangement.
* Both the second and the third functions return pair<Halfedge_handle, bool>,
* where the halfedge handle corresponds to the halfedge created or modified
* by the visitor (if valid), and the Boolean value indicates whether we
* should halt the zone-computation process.
*
* This class improves the complexity of the zone algorithm of
* Arrangement_zone_2 for the cases where we enter a face many times
*/
template <class Arrangement_, class ZoneVisitor_>
class Envelope_arrangement_zone_2 :
public Arrangement_zone_2< Arrangement_, ZoneVisitor_ >,
public Arr_observer< Arrangement_ >
{
public:
typedef Arrangement_ Arrangement_2;
typedef typename Arrangement_2::Traits_2 Traits_2;
typedef ZoneVisitor_ Visitor;
typedef typename Arrangement_2::Vertex_handle Vertex_handle;
typedef typename Arrangement_2::Halfedge_handle Halfedge_handle;
typedef typename Arrangement_2::Face_handle Face_handle;
typedef std::pair<Halfedge_handle, bool> Visitor_result;
typedef typename Traits_2::Point_2 Point_2;
typedef typename Traits_2::X_monotone_curve_2 X_monotone_curve_2;
typedef Arrangement_zone_2< Arrangement_2, Visitor >
Base_zone_2;
typedef Arr_observer< Arrangement_2 > Base_observer;
protected:
typedef typename Arrangement_2::Ccb_halfedge_circulator
Ccb_halfedge_circulator;
typedef Arr_traits_adaptor_2<Traits_2> Traits_adaptor_2;
// Types used for caching intersection points:
typedef std::pair<Point_2, unsigned int> Intersect_point_2;
typedef std::list<CGAL::Object> Intersect_list;
typedef std::map<const X_monotone_curve_2*,
Intersect_list> Intersect_map;
typedef typename Intersect_map::iterator Intersect_map_iterator;
typedef std::set<const X_monotone_curve_2*> Curves_set;
typedef typename Curves_set::iterator Curves_set_iterator;
// Data member:
// Set of faces that we dealt with already
Unique_hash_map<Face_handle, bool> discovered_faces;
// map halfedges that were split to the right part of it
// (which is the only part that might be encountered later again.
class Less_halfedge
{
public:
bool operator()(Halfedge_handle h1, Halfedge_handle h2)
{
return (&*h1 < &*h2);
}
};
typedef std::map<Halfedge_handle, Halfedge_handle,Less_halfedge> Halfedges_map;
typedef typename Halfedges_map::iterator Halfedges_map_iter;
Halfedges_map split_map;
// Set of features (halfedges and vertices) that intersect cv
// (the current portion of the query curve), ordered according to the
// intersection order on cv from left to right
class Less_inter_vertex
{
public:
Less_inter_vertex(Traits_adaptor_2* t) : traits(t)
{}
bool operator() (const Vertex_handle& v1,
const Vertex_handle& v2) const
{
return (traits->compare_xy_2_object()(v1->point(), v2->point())
== SMALLER);
}
protected:
Traits_adaptor_2 *traits;
};
class Less_inter_edge
{
public:
Less_inter_edge(Traits_adaptor_2 *t, Intersect_map& imap) :
traits(t), zone_inter_map(imap)
{}
bool operator() (const Halfedge_handle& h1,
const Halfedge_handle& h2) const
{
// find the leftmost intersection with each curve
// (the curves must be in the inter_map)
const Intersect_point_2 *ip;
const X_monotone_curve_2 *icv;
Point_2 ip1, ip2;
bool no_inter1, no_inter2;
Intersect_map_iterator iter = zone_inter_map.find (&(h1->curve()));
CGAL_assertion(iter != zone_inter_map.end());
if (iter != zone_inter_map.end())
{
// Retrieve the intersections list from the map.
Intersect_list& inter_list = iter->second;
if (inter_list.empty())
no_inter1 = true;
else
{
no_inter1 = false;
// Locate the first intersection
// Compare that current object with left_pt.
ip = object_cast<Intersect_point_2> (&(inter_list.front()));
if (ip != NULL)
ip1 = ip->first;
else
{
icv = object_cast<X_monotone_curve_2> (&(inter_list.front()));
CGAL_assertion (icv != NULL);
ip1 = traits->construct_min_vertex_2_object()(*icv);
}
}
}
iter = zone_inter_map.find (&(h2->curve()));
CGAL_assertion(iter != zone_inter_map.end());
if (iter != zone_inter_map.end())
{
// Retrieve the intersections list from the map.
Intersect_list& inter_list = iter->second;
if (inter_list.empty())
no_inter2 = true;
else
{
no_inter2 = false;
// Locate the first intersection
// Compare that current object with left_pt.
ip = object_cast<Intersect_point_2> (&(inter_list.front()));
if (ip != NULL)
ip2 = ip->first;
else
{
icv = object_cast<X_monotone_curve_2> (&(inter_list.front()));
CGAL_assertion (icv != NULL);
ip2 = traits->construct_min_vertex_2_object()(*icv);
}
}
}
// if (no_inter1 && no_inter2)
// return (h1 < h2);
// else if (no_inter1)
// return false;
// else if (no_inter2)
// return true;
// else
CGAL_assertion(!no_inter1 && !no_inter2);
return (traits->compare_xy_2_object()(ip1, ip2) == SMALLER);
}
protected:
Traits_adaptor_2 *traits;
Intersect_map &zone_inter_map;
};
typedef std::set<Halfedge_handle, Less_inter_edge> Halfedge_sorted_set;
typedef typename Halfedge_sorted_set::iterator He_sorted_set_iter;
Halfedge_sorted_set intersect_he_sorted_set;
typedef std::set<Vertex_handle, Less_inter_vertex> Vertices_sorted_set;
typedef typename Vertices_sorted_set::iterator V_sorted_set_iter;
Vertices_sorted_set intersect_v_sorted_set;
public:
/*!
* Constructor. typename Arrangement_2::Ccb_halfedge_circulator
* \param _arr The arrangement for which we compute the zone.
* \param _visitor A pointer to a zone-visitor object.
*/
Envelope_arrangement_zone_2 (Arrangement_2& _arr,
Visitor *_visitor) :
Base_zone_2(_arr, _visitor),
Base_observer(_arr),
intersect_he_sorted_set(Less_inter_edge(traits, inter_map)),
intersect_v_sorted_set(Less_inter_vertex(traits))
{
}
virtual ~Envelope_arrangement_zone_2(){}
/*!
* Compute the zone of the given curve and issue the apporpriate
* notifications for the visitor.
*/
virtual void compute_zone ()
{
Base_zone_2::compute_zone();
intersect_v_sorted_set.clear();
intersect_he_sorted_set.clear();
discovered_faces.clear();
split_map.clear();
}
/*!
* Notification after an edge was split.
* \param e1 A handle to one of the twin halfedges forming the first edge.
* \param e2 A handle to one of the twin halfedges forming the second edge.
*/
virtual void after_split_edge (Halfedge_handle e1,
Halfedge_handle e2)
{
// we assume that e1 is the original edge that was split
// update split_map with the pair e1 and the rightmost
// halfedge part
if (e1->direction() == LARGER)
{
split_map[e1] = e2;
split_map[e1->twin()] = e2;
}
// in the other case, don't need the map
}
/*!
* Notification after a face was split.
* \param f A handle to the face we have just split.
* \param new_f A handle to the new face that has been created.
* \param is_hole Whether the new face forms a hole inside f.
*/
virtual void after_split_face (Face_handle f,
Face_handle new_f,
bool is_hole)
{
// update the set of discovered faces
if (discovered_faces.is_defined(f))
discovered_faces[new_f] = discovered_faces.default_value();
}
protected:
/*!
* Compute the (lexicographically) leftmost intersection of the query
* curve with the boundary of a given face in the arrangement.
* The function computes sets intersect_p, intersect_he (or alternatively
* overlap_cv and intersect_he) and set the flags found_intersect and
* found_overlap accordingly.
* \param face A handle to the face.
* \param on_boundary Specifies whether the left endpoint of the curve lies
* on the face boundary.
*/
virtual void _leftmost_intersection_with_face_boundary (Face_handle face,
bool on_boundary)
{
found_intersect = false;
found_overlap = false;
found_iso_vert = false;
// Go over the outer boundary of the face (if one exists), and try to
// locate intersections of cv with the edges along the boundary.
typename Traits_adaptor_2::Compare_xy_2 compare_xy =
traits->compare_xy_2_object();
typename Traits_adaptor_2::Is_in_x_range_2 is_in_x_range =
traits->is_in_x_range_2_object();
typename Traits_adaptor_2::Construct_min_vertex_2 min_vertex =
traits->construct_min_vertex_2_object();
typename Traits_adaptor_2::Construct_max_vertex_2 max_vertex =
traits->construct_max_vertex_2_object();
typename Traits_adaptor_2::Compare_y_at_x_2 compare_y_at_x =
traits->compare_y_at_x_2_object();
//Base_zone_2::_leftmost_intersection_with_face_boundary(face, on_boundary);
if (!discovered_faces.is_defined(face))
{
// find all intersections with face boundary, and insert into the
// intersection sets
Ccb_halfedge_circulator he_first;
if (! face->is_unbounded())
{
// Get circulators for the outer boundary of the face.
he_first = face->outer_ccb();
_intersect_with_ccb(he_first, on_boundary);
}
typename Arrangement_2::Hole_iterator holes_it;
for (holes_it = face->holes_begin();
holes_it != face->holes_end(); ++holes_it)
{
// Get circulators for the boundary of the current hole.
he_first = *holes_it;
_intersect_with_ccb(he_first, on_boundary);
}
typename Arrangement_2::Isolated_vertex_iterator iso_verts_it;
for (iso_verts_it = face->isolated_vertices_begin();
iso_verts_it != face->isolated_vertices_end(); ++iso_verts_it)
{
// If the isolated vertex is not in the x-range of our curve, disregard it.
if (! is_in_x_range (cv, iso_verts_it->point()))
continue;
// In case the isolated vertex lies on the curve, add it to the
// intersection vertex set
if (compare_y_at_x (iso_verts_it->point(), cv) == EQUAL)
{
intersect_v_sorted_set.insert(iso_verts_it);
}
} // End:: traversal of the isolated vertices inside the face.
// mark that we discovered the current face
discovered_faces[face] = discovered_faces.default_value();
}
// find the leftmost intersection (it should relate to the current face)
// should find the halfedge with the leftmost intersection
// and the isolated point with the leftmost intersection
// and compare them
bool he_exist, v_exist;
// the leftmost intersections
Point_2 vp, hep;
V_sorted_set_iter v_iter;
He_sorted_set_iter he_iter;
bool he_inter_is_point;
Halfedge_handle inter_he;
if (intersect_v_sorted_set.empty())
v_exist = false;
else
{
v_exist = true;
v_iter = intersect_v_sorted_set.begin();
vp = (*v_iter)->point();
}
CGAL::Object obj;
const Intersect_point_2 *int_p;
const X_monotone_curve_2 *icv;
Point_2 ip;
if (intersect_he_sorted_set.empty())
he_exist = false;
else
{
do
{
he_iter = intersect_he_sorted_set.begin();
// now find the next intersection with this halfedge
// todo: is the false ok?
Halfedges_map_iter split_iter = split_map.find(inter_he);
if (split_iter == split_map.end())
inter_he = *he_iter;
else
{
Halfedge_handle old = inter_he;
inter_he = split_iter->second;
split_map.erase(old);
}
obj = _compute_next_intersection (inter_he, false);
if (obj.is_empty())
intersect_he_sorted_set.erase(he_iter);
}
while(obj.is_empty() && !intersect_he_sorted_set.empty());
if (intersect_he_sorted_set.empty())
he_exist = false;
else
{
he_exist = true;
CGAL_assertion (! obj.is_empty());
// We have found an intersection (either a simple point or an
// overlapping x-monotone curve).
int_p = object_cast<Intersect_point_2> (&obj);
if (int_p != NULL)
{
hep = int_p->first;
he_inter_is_point = true;
}
else
{
// We have located an overlapping curve. Assign ip as its left
// endpoint.
icv = object_cast<X_monotone_curve_2> (&obj);
CGAL_assertion (icv != NULL);
hep = min_vertex (*icv);
he_inter_is_point = false;
}
}
}
if (!v_exist && !he_exist)
return; // no intersection at all
if (v_exist && he_exist)
{
// compare the intersections of the vertex and the halfedge
// and return the leftmost between them
Comparison_result res = compare_xy(hep, vp);
CGAL_assertion(res != EQUAL); // imposible intersection between halfedge
// and isolated vertex
// change v_exist/he_exist in order for the below conditiona to work
if (res == SMALLER)
// halfedge wins
v_exist = false;
else
he_exist = false;
}
if (v_exist && !he_exist)
{
// return the intersection with isolated vertex
intersect_v = *v_iter;
intersect_p = intersect_v->point();
ip_mult = 0;
found_intersect = true;
found_iso_vert = true;
// remove the vertex from the sorted set
intersect_v_sorted_set.erase(v_iter);
return;
}
if (!v_exist && he_exist)
{
// return the intersection with a halfedge
if (he_inter_is_point)
{
intersect_p = hep;
ip_mult = int_p->second;
intersect_he = inter_he;
found_intersect = true;
}
else
{
// begin of overlapping curve
intersect_p = hep;
ip_mult = 0;
overlap_cv = *icv;
intersect_he = inter_he;
found_overlap = true;
found_intersect = true;
}
// remove the halfedge from the sorted intersection set
intersect_he_sorted_set.erase(he_iter);
// remove the found intersection from the list, and if the list is not
// empty, reenter the halfedge into the sorted set
_remove_next_intersection(intersect_he);
Intersect_map_iterator iter = inter_map.find(&(intersect_he->curve()));
Intersect_list& inter_list = iter->second;
if (!inter_list.empty())
intersect_he_sorted_set.insert(intersect_he);
// todo: should remove all halfedges that intersect in the same point from the set
}
}
void _intersect_with_ccb(Ccb_halfedge_circulator he_first, bool on_boundary)
{
typename Traits_adaptor_2::Compare_xy_2 compare_xy =
traits->compare_xy_2_object();
typename Traits_adaptor_2::Is_in_x_range_2 is_in_x_range =
traits->is_in_x_range_2_object();
typename Traits_adaptor_2::Construct_min_vertex_2 min_vertex =
traits->construct_min_vertex_2_object();
typename Traits_adaptor_2::Construct_max_vertex_2 max_vertex =
traits->construct_max_vertex_2_object();
typename Traits_adaptor_2::Compare_y_at_x_2 compare_y_at_x =
traits->compare_y_at_x_2_object();
CGAL::Object obj;
Point_2 ip;
bool left_equals_curr_endpoint;
Ccb_halfedge_circulator he_curr = he_first;
do
{
// If we have already found an intersection with the twin halfedge,
// we do not have to compute intersections with the current halfedge.
// This happens if we already discovered the twin's face
// todo: this doesn't work for antennas!
if (discovered_faces.is_defined(he_curr->twin()->face()) ||
inter_map.find(&(he_curr->curve())) != inter_map.end())
{
++he_curr;
continue;
}
left_equals_curr_endpoint = false;
if (on_boundary)
{
// Check if the left endpoint of the inserted curve (which is located
// on the boundary of our face) equals one of the endpoints of the
// current halfedge. If it equals the right endpoint of the current
// halfedge, we can skip this edge, as there is no true overlap in
// the x-range. Otherwise, we keep track of the fact that left_v is
// the left end-vertex of the current halfedge.
if (he_curr->target() == left_v)
{
left_equals_curr_endpoint = true;
if (he_curr->direction() == SMALLER)
{
++he_curr;
continue;
}
}
else if (he_curr->source() == left_v)
{
left_equals_curr_endpoint = true;
if (he_curr->direction() == LARGER)
{
++he_curr;
continue;
}
}
}
// Check whether the two curves overlap in their x-range (in order
// to avoid unnecessary intersection computations).
if (! left_equals_curr_endpoint &&
(compare_xy (max_vertex (he_curr->curve()), left_pt) != LARGER ||
! is_in_x_range (cv, he_curr->curve())))
{
// In case there is no overlap, the two x-monotone curves obviously
// do not intersect.
++he_curr;
continue;
}
// The intersection of the halfedge with the curve have not been
// computed yet, so we have to compute them now.
// Note that the first curve we intersect is
// always the subcurve associated with the given halfegde and the second
// curve is the one we insert. Even though the order seems unimportant, we
// exploit this fact in some of the traits classes in order to optimize
// computations.
Intersect_list inter_list;
traits->intersect_2_object() (he_curr->curve(), cv,
std::back_inserter(inter_list));
// if there is intersection with the halfedge endpoint, we remove it
if (! inter_list.empty() && left_equals_curr_endpoint)
inter_list.pop_front();
// Insert the list of valid intersections into the map.
inter_map[&(he_curr->curve())] = inter_list;
if (! inter_list.empty())
{
// insert the intersection to the sorted est
intersect_he_sorted_set.insert(he_curr);
}
// Move to the next edge along the ccb
++he_curr;
} while (he_curr != he_first);
}
};
CGAL_END_NAMESPACE
#endif
Reference in New Issue View Git Blame Copy Permalink