mirror of https://github.com/CGAL/cgal
removing files
This commit is contained in:
Baruch Zukerman
parent
7a58b5bdda
commit
41a7ba11d1
|
|
@ -1,630 +0,0 @@
|
||||||
// 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
|
|
||||||
|
|
@ -1,60 +0,0 @@
|
||||||
// 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_NO_VERTICAL_DECOMPOSITION_2_H
|
|
||||||
#define CGAL_NO_VERTICAL_DECOMPOSITION_2_H
|
|
||||||
|
|
||||||
CGAL_BEGIN_NAMESPACE
|
|
||||||
|
|
||||||
// No_vertical_decomposition is a class with the interface needed for
|
|
||||||
// vertical decomposition, which doesn't do a decomposition at all
|
|
||||||
template <class ArrangementWithOverlayData>
|
|
||||||
class No_vertical_decomposition_2
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
typedef ArrangementWithOverlayData Pmwx;
|
|
||||||
typedef typename Pmwx::Halfedge_iterator Halfedge_iterator;
|
|
||||||
typedef typename Pmwx::Halfedge_handle Halfedge_handle;
|
|
||||||
typedef typename Pmwx::Face_handle Face_handle;
|
|
||||||
typedef typename Pmwx::Face_iterator Face_iterator;
|
|
||||||
typedef typename Pmwx::Ccb_halfedge_circulator Ccb_halfedge_circulator;
|
|
||||||
typedef typename Pmwx::Hole_iterator Hole_iterator;
|
|
||||||
typedef typename Pmwx::Face_const_iterator Face_const_iterator;
|
|
||||||
typedef typename Pmwx::Vertex_iterator Vertex_iterator;
|
|
||||||
typedef typename Pmwx::Vertex_handle Vertex_handle;
|
|
||||||
|
|
||||||
typedef typename Pmwx::Traits_2 Traits;
|
|
||||||
typedef typename Traits::X_monotone_curve_2 X_monotone_curve_2;
|
|
||||||
typedef typename Traits::Curve_2 Curve_2;
|
|
||||||
typedef typename Traits::Point_2 Point_2;
|
|
||||||
|
|
||||||
typedef typename Pmwx::Dcel Pm_dcel;
|
|
||||||
typedef typename Pm_dcel::Face_data Pm_face_data;
|
|
||||||
|
|
||||||
void operator()(Pmwx& pm)
|
|
||||||
{
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
CGAL_END_NAMESPACE
|
|
||||||
|
|
||||||
#endif // OVERLAY_2_H
|
|
||||||
|
|
@ -1,174 +0,0 @@
|
||||||
// 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_PARTIAL_VD_META_TRAITS_H
|
|
||||||
#define CGAL_PARTIAL_VD_META_TRAITS_H
|
|
||||||
|
|
||||||
|
|
||||||
CGAL_BEGIN_NAMESPACE
|
|
||||||
|
|
||||||
template <class Traits, class Arrangement_>
|
|
||||||
class Partial_vd_meta_traits : public Traits
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
typedef Arrangement_ Arrangement;
|
|
||||||
typedef typename Arrangement::Halfedge_const_handle Halfedge_const_handle;
|
|
||||||
typedef typename Arrangement::Vertex_const_handle Vertex_const_handle;
|
|
||||||
|
|
||||||
typedef typename Traits::X_monotone_curve_2 Base_X_monotone_curve_2;
|
|
||||||
typedef typename Traits::Point_2 Base_Point_2;
|
|
||||||
typedef typename Traits::Construct_min_vertex_2 Base_construct_min_vertex_2;
|
|
||||||
typedef typename Traits::Construct_max_vertex_2 Base_construct_max_vertex_2;
|
|
||||||
|
|
||||||
// nested class My_X_monotone_curve_2
|
|
||||||
class My_X_monotone_curve_2 : public Base_X_monotone_curve_2
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
typedef Base_X_monotone_curve_2 Base;
|
|
||||||
|
|
||||||
friend class Partial_vd_meta_traits<Traits,
|
|
||||||
Halfedge_const_handle>;
|
|
||||||
|
|
||||||
My_X_monotone_curve_2():Base(),
|
|
||||||
m_he_handle(NULL)
|
|
||||||
{}
|
|
||||||
|
|
||||||
My_X_monotone_curve_2(const Base& cv):Base(cv),
|
|
||||||
m_he_handle(NULL)
|
|
||||||
{}
|
|
||||||
|
|
||||||
My_X_monotone_curve_2(const Base&cv, Halfedge_const_handle he):Base(cv),
|
|
||||||
m_he_handle(he)
|
|
||||||
{}
|
|
||||||
|
|
||||||
|
|
||||||
Halfedge_const_handle get_halfedge_handle() const
|
|
||||||
{
|
|
||||||
return m_he_handle;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
protected:
|
|
||||||
Halfedge_const_handle m_he_handle;
|
|
||||||
}; // nested class My_X_monotone_curve_2 - END
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
class My_Point_2 : public Base_Point_2
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
typedef Base_Point_2 Base;
|
|
||||||
|
|
||||||
friend class Partial_vd_meta_traits<Traits,
|
|
||||||
Halfedge_const_handle>;
|
|
||||||
|
|
||||||
My_Point_2(): Base(),
|
|
||||||
m_v(NULL)
|
|
||||||
{}
|
|
||||||
|
|
||||||
My_Point_2(const Base& pt): Base(pt),
|
|
||||||
m_v(NULL)
|
|
||||||
{}
|
|
||||||
|
|
||||||
My_Point_2(const Base& pt, Vertex_const_handle v): Base(pt), m_v(v)
|
|
||||||
{}
|
|
||||||
|
|
||||||
|
|
||||||
Vertex_const_handle get_vertex_handle() const
|
|
||||||
{
|
|
||||||
return m_v;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
protected:
|
|
||||||
Vertex_const_handle m_v;
|
|
||||||
}; // nested class My_Point_2 - END
|
|
||||||
|
|
||||||
typedef My_X_monotone_curve_2 X_monotone_curve_2;
|
|
||||||
typedef My_Point_2 Point_2;
|
|
||||||
|
|
||||||
class Construct_min_vertex_2
|
|
||||||
{
|
|
||||||
private:
|
|
||||||
Base_construct_min_vertex_2 m_base_cons_min;
|
|
||||||
|
|
||||||
public:
|
|
||||||
|
|
||||||
/*! Constructor. */
|
|
||||||
Construct_min_vertex_2 (const Base_construct_min_vertex_2& base) :
|
|
||||||
m_base_cons_min (base)
|
|
||||||
{}
|
|
||||||
|
|
||||||
Point_2 operator() (const X_monotone_curve_2 & cv) const
|
|
||||||
{
|
|
||||||
const Base_Point_2& pt = m_base_cons_min(cv);
|
|
||||||
CGAL_assertion_code(Traits traits);
|
|
||||||
CGAL_assertion(traits.equal_2_object()(pt, cv.get_halfedge_handle()->source()->point()));
|
|
||||||
// the halfedge in cv should be directed from left to right
|
|
||||||
Point_2 p(pt, cv.get_halfedge_handle()->source());
|
|
||||||
return p;
|
|
||||||
}
|
|
||||||
|
|
||||||
};
|
|
||||||
|
|
||||||
/*! Get a Construct_min_vertex_2 functor object. */
|
|
||||||
Construct_min_vertex_2 construct_min_vertex_2_object() const
|
|
||||||
{
|
|
||||||
return Construct_min_vertex_2(Traits::construct_min_vertex_2_object());
|
|
||||||
}
|
|
||||||
|
|
||||||
class Construct_max_vertex_2
|
|
||||||
{
|
|
||||||
private:
|
|
||||||
Base_construct_max_vertex_2 m_base_cons_max;
|
|
||||||
|
|
||||||
public:
|
|
||||||
|
|
||||||
/*! Constructor. */
|
|
||||||
Construct_max_vertex_2 (const Base_construct_max_vertex_2& base) :
|
|
||||||
m_base_cons_max (base)
|
|
||||||
{}
|
|
||||||
|
|
||||||
Point_2 operator() (const X_monotone_curve_2 & cv) const
|
|
||||||
{
|
|
||||||
const Base_Point_2& pt = m_base_cons_max(cv);
|
|
||||||
CGAL_assertion_code(Traits traits);
|
|
||||||
CGAL_assertion(traits.equal_2_object()(pt, cv.get_halfedge_handle()->target()->point()));
|
|
||||||
// the halfedge in cv should be directed from left to right
|
|
||||||
Point_2 p(pt, cv.get_halfedge_handle()->target());
|
|
||||||
return p;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
/*! Get a Construct_max_vertex_2 functor object. */
|
|
||||||
Construct_max_vertex_2 construct_max_vertex_2_object () const
|
|
||||||
{
|
|
||||||
return Construct_max_vertex_2(Traits::construct_max_vertex_2_object());
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
public:
|
|
||||||
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
CGAL_END_NAMESPACE
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,320 +0,0 @@
|
||||||
// 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_PARTIAL_VD_VISITOR_H
|
|
||||||
#define CGAL_PARTIAL_VD_VISITOR_H
|
|
||||||
|
|
||||||
#include <CGAL/Sweep_line_2_empty_visitor.h>
|
|
||||||
#include <CGAL/Object.h>
|
|
||||||
#include <utility>
|
|
||||||
|
|
||||||
CGAL_BEGIN_NAMESPACE
|
|
||||||
|
|
||||||
template< class Traits_, class Arrangement_, class OutputIterator>
|
|
||||||
class Partial_vd_visitor : public Empty_visitor< Traits_ >
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
|
|
||||||
typedef Partial_vd_visitor<Traits_,
|
|
||||||
Arrangement_,
|
|
||||||
OutputIterator> Self;
|
|
||||||
typedef Arrangement_ Arrangement;
|
|
||||||
typedef Traits_ Traits;
|
|
||||||
|
|
||||||
|
|
||||||
typedef Empty_visitor<Traits> Base;
|
|
||||||
typedef typename Base::Event Event;
|
|
||||||
typedef typename Base::Subcurve Subcurve;
|
|
||||||
typedef typename Base::SL_iterator SL_iterator;
|
|
||||||
typedef typename Base::SubCurveIter SubCurveIter;
|
|
||||||
typedef typename Base::SubCurveRevIter SubCurveRevIter;
|
|
||||||
|
|
||||||
|
|
||||||
typedef typename Traits::X_monotone_curve_2 X_monotone_curve_2;
|
|
||||||
typedef typename Traits::Point_2 Point_2;
|
|
||||||
typedef typename Traits::Base_Point_2 Base_Point_2;
|
|
||||||
typedef typename Arrangement::Halfedge_const_handle Halfedge_const_handle;
|
|
||||||
typedef typename Arrangement::Vertex_const_handle Vertex_const_handle;
|
|
||||||
typedef std::pair<Object, Object> Vd_Pair;
|
|
||||||
|
|
||||||
Partial_vd_visitor(const Arrangement& arr, OutputIterator o) :
|
|
||||||
m_arr(arr), m_out(o), m_last_event(NULL), m_last_above(NULL),
|
|
||||||
m_is_last_pair(false), m_last_should_shoot_down(false),
|
|
||||||
m_last_should_shoot_up(false)
|
|
||||||
{}
|
|
||||||
|
|
||||||
//after_handle_event
|
|
||||||
//(above_on_event is true iff 'above' subcurve is on the event
|
|
||||||
bool after_handle_event(Event* event, SL_iterator above, bool above_on_event)
|
|
||||||
{
|
|
||||||
// we should never have above_on_event = true since we sweep an existing
|
|
||||||
// arrangement
|
|
||||||
CGAL_assertion(!above_on_event);
|
|
||||||
|
|
||||||
Vertex_const_handle vh = event->get_point().get_vertex_handle();
|
|
||||||
CGAL_assertion(vh != Vertex_const_handle(NULL));
|
|
||||||
CGAL_assertion(m_arr.get_traits()->equal_2_object()(event->get_point(),
|
|
||||||
vh->point()));
|
|
||||||
|
|
||||||
// these booleans are needed for "LESANEN" vertical edges in a partial
|
|
||||||
// vertical decomposition
|
|
||||||
bool event_should_shoot_down = should_shoot_down(event);
|
|
||||||
bool event_should_shoot_up = should_shoot_up(event);
|
|
||||||
|
|
||||||
// this bool is used for solving 2 problems:
|
|
||||||
// 1. the redundant problem, where 2 vertices see each other, and we might
|
|
||||||
// discover this pair twice
|
|
||||||
// 2. a problem where when shooting down what we see is not exactly right
|
|
||||||
// below the current event, since there were events in the middle that
|
|
||||||
// were removed from the status line (with same x coordinate)
|
|
||||||
bool previous_event_see_current = false;
|
|
||||||
// if last event is set, we should check if we interrupt its above sight
|
|
||||||
if (m_is_last_pair)
|
|
||||||
{
|
|
||||||
CGAL_assertion(m_last_event != NULL);
|
|
||||||
// special cases can happen if we stay in the same x-coordinate sweepline
|
|
||||||
if(m_arr.get_traits()->compare_x_2_object()
|
|
||||||
(m_last_event->get_point(), event->get_point())
|
|
||||||
== EQUAL &&
|
|
||||||
((above == this->status_line_end() && m_last_above == NULL) ||
|
|
||||||
(above != this->status_line_end() && m_last_above == *above) ||
|
|
||||||
(event == m_last_above->get_right_event()) // last above ends in the current event
|
|
||||||
))
|
|
||||||
{
|
|
||||||
// should change the previous pair - is sees the current event point
|
|
||||||
// instead of the previous above curve
|
|
||||||
Vertex_const_handle pvh = m_last_event->get_point().get_vertex_handle();
|
|
||||||
if (event_should_shoot_down || m_last_should_shoot_up)
|
|
||||||
*m_out++ = std::make_pair(CGAL::make_object(pvh),
|
|
||||||
CGAL::make_object(vh));
|
|
||||||
|
|
||||||
previous_event_see_current = true;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
// keep the previous pair, if existed
|
|
||||||
if (m_last_above != NULL)
|
|
||||||
{
|
|
||||||
Halfedge_const_handle phe = m_last_above->get_last_curve().get_halfedge_handle();
|
|
||||||
Vertex_const_handle pvh = m_last_event->get_point().get_vertex_handle();
|
|
||||||
CGAL_assertion(m_arr.get_traits()->equal_2_object()(m_last_event->get_point(),
|
|
||||||
pvh->point()));
|
|
||||||
if (m_last_should_shoot_up)
|
|
||||||
*m_out++ = std::make_pair(CGAL::make_object(pvh),
|
|
||||||
CGAL::make_object(phe));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// todo: check if we should shoot from this point
|
|
||||||
|
|
||||||
// if the event is an end of a vertical segment, we don't shoot down
|
|
||||||
bool vertical_end = false;
|
|
||||||
SubCurveIter lci = event->left_curves_begin();
|
|
||||||
for(; lci != event->left_curves_end(); ++lci)
|
|
||||||
{
|
|
||||||
if (m_arr.get_traits()->is_vertical_2_object()((*lci)->get_last_curve()))
|
|
||||||
{
|
|
||||||
vertical_end = true;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
if (!vertical_end)
|
|
||||||
{
|
|
||||||
// shoot down
|
|
||||||
// if previous event sees the current event, then we don't have to shoot
|
|
||||||
// down, since this pair was already discovered
|
|
||||||
if (!previous_event_see_current)
|
|
||||||
{
|
|
||||||
// find who is right below the event point in the sweep line
|
|
||||||
int num_of_right_curves = event->get_num_right_curves();
|
|
||||||
SL_iterator below = above;
|
|
||||||
int i;
|
|
||||||
for(i=0; i<=num_of_right_curves && below != this->status_line_begin();
|
|
||||||
++i, --below);
|
|
||||||
|
|
||||||
if (i == (num_of_right_curves+1))
|
|
||||||
{
|
|
||||||
// we see something below us
|
|
||||||
// is it not an isolated point, since these were already removed from
|
|
||||||
// the status line
|
|
||||||
// it is also not an endpoint, since in this case, we would have
|
|
||||||
// previous_event_see_current = true
|
|
||||||
CGAL_assertion(m_arr.get_traits()->equal_2_object()(event->get_point(),
|
|
||||||
vh->point()));
|
|
||||||
|
|
||||||
// assert it is not an endpoint
|
|
||||||
CGAL_assertion_code(
|
|
||||||
Event* left_event = (*below)->get_left_event();
|
|
||||||
);
|
|
||||||
CGAL_assertion(m_arr.get_traits()->compare_x_2_object()
|
|
||||||
(left_event->get_point(), event->get_point()) != EQUAL);
|
|
||||||
|
|
||||||
Halfedge_const_handle he = (*below)->get_last_curve().get_halfedge_handle();
|
|
||||||
if (event_should_shoot_down)
|
|
||||||
*m_out++ = std::make_pair(CGAL::make_object(vh), CGAL::make_object(he));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// if the event is a start of a vertical segment, we don't shoot up
|
|
||||||
bool vertical_start = false;
|
|
||||||
lci = event->right_curves_begin();
|
|
||||||
for(; lci != event->right_curves_end(); ++lci)
|
|
||||||
{
|
|
||||||
if (m_arr.get_traits()->is_vertical_2_object()((*lci)->get_last_curve()))
|
|
||||||
{
|
|
||||||
vertical_start = true;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
m_last_event = event;
|
|
||||||
m_last_above = NULL;
|
|
||||||
m_last_should_shoot_down = event_should_shoot_down;
|
|
||||||
m_last_should_shoot_up = event_should_shoot_up;
|
|
||||||
|
|
||||||
m_is_last_pair = false;
|
|
||||||
if (!vertical_start)
|
|
||||||
{
|
|
||||||
m_is_last_pair = true;
|
|
||||||
// shoot up
|
|
||||||
if (above != this->status_line_end())
|
|
||||||
{
|
|
||||||
m_last_above = *above;
|
|
||||||
// we see something above us, and keep it to be dealt with in the next event
|
|
||||||
CGAL_assertion(m_arr.get_traits()->equal_2_object()(event->get_point(),
|
|
||||||
vh->point()));
|
|
||||||
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
m_events.push_back(event);
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void after_sweep()
|
|
||||||
{
|
|
||||||
typename std::list<Event*>::iterator it = m_events.begin();
|
|
||||||
for(;it != m_events.end(); ++it)
|
|
||||||
this->deallocate_event(*it);
|
|
||||||
}
|
|
||||||
|
|
||||||
protected:
|
|
||||||
// check if should shoot down/up from the evnet's point
|
|
||||||
// in partial vertical decomposition, we should check if the angle
|
|
||||||
// formed by the edges which we insert the vertical segment between
|
|
||||||
// is less than 180
|
|
||||||
bool should_shoot_down(Event* event)
|
|
||||||
{
|
|
||||||
// if no curve ends in this event we always get angel > 180 in the
|
|
||||||
// down direction
|
|
||||||
if (!event->has_left_curves())
|
|
||||||
return true;
|
|
||||||
|
|
||||||
// we have at least one curve that ends in this event, we take the lowest
|
|
||||||
// one
|
|
||||||
// if we have a vertical curve downwards, then it should be it (and we
|
|
||||||
// don't shoot down)
|
|
||||||
// (we can use get_last_curve() since we work on existing arrangement
|
|
||||||
// and don't split the curves)
|
|
||||||
SubCurveIter lci = event->left_curves_begin();
|
|
||||||
if (m_arr.get_traits()->is_vertical_2_object()((*lci)->get_last_curve()))
|
|
||||||
return false;
|
|
||||||
|
|
||||||
// if we don't have any curves that begin in this event, the angel is
|
|
||||||
// always > 180 in the down direction
|
|
||||||
if (!event->has_right_curves())
|
|
||||||
return true;
|
|
||||||
|
|
||||||
// get the lowest right curve
|
|
||||||
SubCurveIter rci = event->right_curves_begin();
|
|
||||||
|
|
||||||
// TODO: be careful - this check is only true for segments -
|
|
||||||
// we should check the angle between curves and not between points
|
|
||||||
// should define it more carefully within the traits
|
|
||||||
|
|
||||||
Point_2 left = (*lci)->get_last_curve().source();
|
|
||||||
Point_2 right = (*rci)->get_last_curve().target();
|
|
||||||
// if (left, event->point(), right) is a left turn can shoot down
|
|
||||||
// return m_arr.get_traits()->leftturn_2_object()(left, event->get_point(), right);
|
|
||||||
return CGAL::left_turn(left, event->get_point(), right);
|
|
||||||
}
|
|
||||||
|
|
||||||
bool should_shoot_up(Event* event)
|
|
||||||
{
|
|
||||||
// if no curve starts in this event we always get angel > 180 in the
|
|
||||||
// up direction
|
|
||||||
if (!event->has_right_curves())
|
|
||||||
return true;
|
|
||||||
|
|
||||||
// we have at least one curve that starts in this event, we take the
|
|
||||||
// highest one
|
|
||||||
// if we have a vertical curve upwards, then it should be it (and we
|
|
||||||
// don't shoot up)
|
|
||||||
// (we can use get_last_curve() since we work on existing arrangement
|
|
||||||
// and don't split the curves)
|
|
||||||
SubCurveRevIter rci = event->right_curves_rbegin();
|
|
||||||
if (m_arr.get_traits()->is_vertical_2_object()((*rci)->get_last_curve()))
|
|
||||||
return false;
|
|
||||||
|
|
||||||
// if we don't have any curves that end in this event, the angel is
|
|
||||||
// always > 180 in the up direction
|
|
||||||
if (!event->has_left_curves())
|
|
||||||
return true;
|
|
||||||
|
|
||||||
// get the highest left curve
|
|
||||||
SubCurveRevIter lci = event->left_curves_rbegin();
|
|
||||||
|
|
||||||
// TODO: be careful - this check is only true for segments -
|
|
||||||
// we should check the angle between curves and not between points
|
|
||||||
// should define it more carefully within the traits
|
|
||||||
|
|
||||||
Point_2 left = (*lci)->get_last_curve().source();
|
|
||||||
Point_2 right = (*rci)->get_last_curve().target();
|
|
||||||
// if (left, event->point(), right) is a right turn can shoot up
|
|
||||||
// return m_arr.get_traits()->right_turn_2_object()(left, event->get_point(), right);
|
|
||||||
return CGAL::right_turn(left, event->get_point(), right);
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
const Arrangement& m_arr;
|
|
||||||
OutputIterator m_out;
|
|
||||||
|
|
||||||
// the last event that was completely handled
|
|
||||||
Event* m_last_event;
|
|
||||||
// the subcurve that was above the last event in the status line of that event
|
|
||||||
Subcurve* m_last_above;
|
|
||||||
// indicate if in the last event, when we shoot up, we might have a
|
|
||||||
// vertical pair
|
|
||||||
bool m_is_last_pair;
|
|
||||||
// last values of should_shoot_down/up
|
|
||||||
bool m_last_should_shoot_down, m_last_should_shoot_up;
|
|
||||||
|
|
||||||
// save all events here, and deallocate them in the end
|
|
||||||
std::list<Event*> m_events;
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
CGAL_END_NAMESPACE
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,249 +0,0 @@
|
||||||
// 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_PARTIAL_VERTICAL_DECOMPOSITION_2_H
|
|
||||||
#define CGAL_PARTIAL_VERTICAL_DECOMPOSITION_2_H
|
|
||||||
|
|
||||||
#include <CGAL/Basic_sweep_line_2.h>
|
|
||||||
#include <CGAL/Sweep_line_2/Sweep_line_subcurve.h>
|
|
||||||
#include <CGAL/Sweep_line_2/Sweep_line_event.h>
|
|
||||||
#include <CGAL/Envelope_3/Partial_vd_visitor.h>
|
|
||||||
#include <CGAL/Envelope_3/Partial_vd_meta_traits.h>
|
|
||||||
#include <CGAL/Unique_hash_map.h>
|
|
||||||
#include <vector>
|
|
||||||
#include <iostream>
|
|
||||||
|
|
||||||
CGAL_BEGIN_NAMESPACE
|
|
||||||
|
|
||||||
// To use this partial vertical decomposition, the arrangement's traits
|
|
||||||
// should supply 2 additional methods:
|
|
||||||
// 1. construct_vertical_2 - to construct a vertical X_monotone_curve_2
|
|
||||||
// from 2 points with same x coordinate
|
|
||||||
// 2. vertical_ray_shoot_2 - to get a point on a X_monotone_curve_2 with
|
|
||||||
// a given x coordinate (assuming it is in the curve's x-range)
|
|
||||||
|
|
||||||
|
|
||||||
template <class Arrangement_>
|
|
||||||
class Partial_vertical_decomposition_2
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
typedef Arrangement_ Arrangement;
|
|
||||||
// Arrangement types:
|
|
||||||
typedef typename Arrangement::Traits_2 Traits_2;
|
|
||||||
typedef typename Traits_2::X_monotone_curve_2 Base_X_monotone_curve_2;
|
|
||||||
typedef typename Traits_2::Point_2 Base_Point_2;
|
|
||||||
|
|
||||||
typedef typename Arrangement::Halfedge_const_handle Halfedge_const_handle;
|
|
||||||
typedef typename Arrangement::Vertex_const_handle Vertex_const_handle;
|
|
||||||
typedef typename Arrangement::Vertex_const_iterator Vertex_const_iterator;
|
|
||||||
typedef typename Arrangement::Edge_const_iterator Edge_const_iterator;
|
|
||||||
typedef typename Arrangement::Halfedge_const_iterator Halfedge_const_iterator;
|
|
||||||
typedef typename Arrangement::Halfedge_handle Halfedge_handle;
|
|
||||||
typedef typename Arrangement::Vertex_handle Vertex_handle;
|
|
||||||
typedef typename Arrangement::Size Size;
|
|
||||||
|
|
||||||
|
|
||||||
// Define meta-traits class for the batched point location:
|
|
||||||
typedef Partial_vd_meta_traits<Traits_2, Arrangement>
|
|
||||||
Meta_traits_2;
|
|
||||||
|
|
||||||
typedef typename Meta_traits_2::X_monotone_curve_2 X_monotone_curve_2;
|
|
||||||
typedef typename Meta_traits_2::Point_2 Point_2;
|
|
||||||
|
|
||||||
typedef std::pair<Object, Object> Vd_pair;
|
|
||||||
typedef std::list<Vd_pair> Vd_pairs_container;
|
|
||||||
typedef std::list<Vd_pair>::iterator Vd_pairs_iter;
|
|
||||||
typedef std::back_insert_iterator<Vd_pairs_container> Vd_pairs_oiter;
|
|
||||||
// Define the sweep-line visitor:
|
|
||||||
typedef Partial_vd_visitor<Meta_traits_2,
|
|
||||||
Arrangement,
|
|
||||||
Vd_pairs_oiter> Visitor;
|
|
||||||
|
|
||||||
typedef Basic_sweep_line_2<Meta_traits_2, Visitor> Sweep_line;
|
|
||||||
|
|
||||||
typedef Unique_hash_map<Halfedge_handle, Halfedge_handle> Halfedges_map;
|
|
||||||
|
|
||||||
// Do a partial vertical decomposition on existing arrangement "arr"
|
|
||||||
void operator()(Arrangement& arr)
|
|
||||||
{
|
|
||||||
// Go over all arrangement edges.
|
|
||||||
std::vector<X_monotone_curve_2> xcurves_vec;
|
|
||||||
xcurves_vec.resize(arr.number_of_edges());
|
|
||||||
typename Traits_2::Compare_xy_2 comp_xy =
|
|
||||||
arr.get_traits()->compare_xy_2_object();
|
|
||||||
Edge_const_iterator eit;
|
|
||||||
|
|
||||||
Size i = 0;
|
|
||||||
for (eit = arr.edges_begin(); eit != arr.edges_end(); ++eit, ++i)
|
|
||||||
{
|
|
||||||
// Associate each x-monotone curve with the halfedge that represent it
|
|
||||||
// that is directed from left to right.
|
|
||||||
if(comp_xy(eit->source()->point(),
|
|
||||||
eit->target()->point()) == SMALLER)
|
|
||||||
xcurves_vec[i] = X_monotone_curve_2(eit->curve(),eit);
|
|
||||||
else
|
|
||||||
xcurves_vec[i] = X_monotone_curve_2(eit->curve(),eit->twin());
|
|
||||||
}
|
|
||||||
|
|
||||||
// Associate each isolated point with the vertex that represents it
|
|
||||||
std::vector<Point_2> iso_points;
|
|
||||||
for(Vertex_const_iterator v_itr = arr.vertices_begin();
|
|
||||||
v_itr != arr.vertices_end();
|
|
||||||
++v_itr)
|
|
||||||
{
|
|
||||||
if(v_itr->is_isolated())
|
|
||||||
iso_points.push_back(Point_2(v_itr->point(), v_itr));
|
|
||||||
}
|
|
||||||
|
|
||||||
// Perform the sweep
|
|
||||||
Vd_pairs_container vd_pairs;
|
|
||||||
Visitor visitor (arr, std::back_inserter(vd_pairs));
|
|
||||||
Sweep_line sweep_line (&visitor);
|
|
||||||
|
|
||||||
sweep_line.sweep(xcurves_vec.begin(),
|
|
||||||
xcurves_vec.end(),
|
|
||||||
iso_points.begin(),
|
|
||||||
iso_points.end());
|
|
||||||
|
|
||||||
_add_vertical_edges(arr, vd_pairs);
|
|
||||||
}
|
|
||||||
|
|
||||||
protected:
|
|
||||||
// add the vertical edges (that were determined by the sweep) to the
|
|
||||||
// arrangement
|
|
||||||
void _add_vertical_edges(Arrangement& arr, Vd_pairs_container& vd_pairs)
|
|
||||||
{
|
|
||||||
Vertex_const_handle invalid_v(NULL);
|
|
||||||
Halfedge_const_handle invalid_he(NULL);
|
|
||||||
|
|
||||||
Halfedge_handle prev_split_he(NULL);
|
|
||||||
Base_Point_2 prev_split_pt;
|
|
||||||
Vertex_handle prev_split_v(NULL);
|
|
||||||
|
|
||||||
// map original halfedge in the arrangement to its current rightmost part
|
|
||||||
// which should be split when more than one split of this halfedge is needed
|
|
||||||
Halfedges_map map_orig_to_rightmost;
|
|
||||||
|
|
||||||
Vd_pairs_iter it = vd_pairs.begin();
|
|
||||||
for(; it != vd_pairs.end(); ++it)
|
|
||||||
{
|
|
||||||
Vd_pair cur_pair = *it;
|
|
||||||
Vertex_const_handle v1, v2;
|
|
||||||
Halfedge_const_handle h1, h2;
|
|
||||||
if (!CGAL::assign(v1, cur_pair.first))
|
|
||||||
{
|
|
||||||
CGAL_assertion(CGAL::assign(h1, cur_pair.first));
|
|
||||||
CGAL::assign(h1, cur_pair.first);
|
|
||||||
}
|
|
||||||
if (!CGAL::assign(v2, cur_pair.second))
|
|
||||||
{
|
|
||||||
CGAL_assertion(CGAL::assign(h2, cur_pair.second));
|
|
||||||
CGAL::assign(h2, cur_pair.second);
|
|
||||||
}
|
|
||||||
// we have 2 vertices, no split is needed
|
|
||||||
if (v1 != invalid_v && v2 != invalid_v)
|
|
||||||
{
|
|
||||||
if (should_add_vertical_edge(arr.non_const_handle(v1), arr.non_const_handle(v2)))
|
|
||||||
{
|
|
||||||
arr.insert_at_vertices(
|
|
||||||
arr.get_traits()->construct_vertical_2_object()(v1->point(), v2->point()),
|
|
||||||
arr.non_const_handle(v1),
|
|
||||||
arr.non_const_handle(v2));
|
|
||||||
}
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
Vertex_handle v;
|
|
||||||
Halfedge_handle orig_split_he, split_he;
|
|
||||||
|
|
||||||
if (v1 != invalid_v)
|
|
||||||
{
|
|
||||||
// we must have h2 valid
|
|
||||||
CGAL_assertion(h2 != invalid_he);
|
|
||||||
v = arr.non_const_handle(v1);
|
|
||||||
orig_split_he = arr.non_const_handle(h2);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
// we must have v2 and h1 valid
|
|
||||||
CGAL_assertion(v2 != invalid_v);
|
|
||||||
CGAL_assertion(h1 != invalid_he);
|
|
||||||
v = arr.non_const_handle(v2);
|
|
||||||
orig_split_he = arr.non_const_handle(h1);
|
|
||||||
}
|
|
||||||
|
|
||||||
if (!should_add_vertical_edge(v, orig_split_he))
|
|
||||||
continue;
|
|
||||||
|
|
||||||
// split split_he and connect the split point with v
|
|
||||||
if (map_orig_to_rightmost.is_defined(orig_split_he))
|
|
||||||
// we should split the rightmost halfedge instead
|
|
||||||
split_he = map_orig_to_rightmost[orig_split_he];
|
|
||||||
else
|
|
||||||
split_he = orig_split_he;
|
|
||||||
|
|
||||||
Base_Point_2 split_p;
|
|
||||||
Vertex_handle split_v;
|
|
||||||
if (prev_split_he == orig_split_he &&
|
|
||||||
arr.get_traits()->compare_x_2_object()(prev_split_pt, v->point()) == EQUAL)
|
|
||||||
{
|
|
||||||
split_p = prev_split_pt;
|
|
||||||
split_v = prev_split_v;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
split_p = arr.get_traits()->vertical_ray_shoot_2
|
|
||||||
(v->point(), split_he->curve());
|
|
||||||
Base_X_monotone_curve_2 a,b;
|
|
||||||
arr.get_traits()->split_2_object()(split_he->curve(), split_p, a, b);
|
|
||||||
split_he = arr.split_edge(split_he, a, b);
|
|
||||||
// split always returns the halfedge with source = original source
|
|
||||||
// so the current rightmost part is split_he->next()
|
|
||||||
map_orig_to_rightmost[orig_split_he] = split_he->next();
|
|
||||||
split_v = split_he->target();
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
prev_split_he = orig_split_he;
|
|
||||||
prev_split_pt = split_p;
|
|
||||||
prev_split_v = split_v;
|
|
||||||
|
|
||||||
// insert the vertical edge
|
|
||||||
arr.insert_at_vertices(
|
|
||||||
arr.get_traits()->construct_vertical_2_object()(v->point(), split_p),
|
|
||||||
v,
|
|
||||||
split_v);
|
|
||||||
}
|
|
||||||
vd_pairs.clear();
|
|
||||||
}
|
|
||||||
|
|
||||||
bool should_add_vertical_edge(Vertex_handle v1, Vertex_handle v2)
|
|
||||||
{
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool should_add_vertical_edge(Vertex_handle v, Halfedge_handle he)
|
|
||||||
{
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
};
|
|
||||||
|
|
||||||
CGAL_END_NAMESPACE
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,115 +0,0 @@
|
||||||
// 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_NUMBER_OF_SURFACES_H
|
|
||||||
#define CGAL_ENVELOPE_NUMBER_OF_SURFACES_H
|
|
||||||
|
|
||||||
#include <iostream>
|
|
||||||
#include <cassert>
|
|
||||||
#include <list>
|
|
||||||
#include <set>
|
|
||||||
|
|
||||||
CGAL_BEGIN_NAMESPACE
|
|
||||||
|
|
||||||
// return the number of different xy-monotone surfaces that appear in the
|
|
||||||
// minimization diagram "arr"
|
|
||||||
template <class MinimizationDiagram_2>
|
|
||||||
std::size_t envelope_find_number_of_surfaces(MinimizationDiagram_2& arr)
|
|
||||||
{
|
|
||||||
typedef MinimizationDiagram_2 Minimization_diagram_2;
|
|
||||||
typedef typename Minimization_diagram_2::Traits_2 Traits_2;
|
|
||||||
typedef typename Traits_2::Xy_monotone_surface_3 Xy_monotone_surface_3;
|
|
||||||
|
|
||||||
typedef std::list<Xy_monotone_surface_3> Surfaces_list;
|
|
||||||
|
|
||||||
Surfaces_list slist;
|
|
||||||
envelope_find_unique_surfaces(arr, std::back_inserter(slist));
|
|
||||||
|
|
||||||
return slist.size();
|
|
||||||
}
|
|
||||||
|
|
||||||
template <class MinimizationDiagram_2, class OutputIterator>
|
|
||||||
OutputIterator envelope_find_unique_surfaces(MinimizationDiagram_2& arr, OutputIterator o)
|
|
||||||
{
|
|
||||||
typedef MinimizationDiagram_2 Minimization_diagram_2;
|
|
||||||
typedef typename Minimization_diagram_2::Traits_2 Traits_2;
|
|
||||||
typedef typename Traits_2::Xy_monotone_surface_3 Xy_monotone_surface_3;
|
|
||||||
|
|
||||||
typedef typename Minimization_diagram_2::Halfedge_iterator Halfedge_iterator;
|
|
||||||
typedef typename Minimization_diagram_2::Face_iterator Face_iterator;
|
|
||||||
typedef typename Minimization_diagram_2::Vertex_iterator Vertex_iterator;
|
|
||||||
typedef typename Minimization_diagram_2::Dcel::Face_data_iterator Data_iterator;
|
|
||||||
|
|
||||||
typedef std::set<Xy_monotone_surface_3> Surfaces_set;
|
|
||||||
typedef typename std::set<Xy_monotone_surface_3>::iterator Surfaces_set_it;
|
|
||||||
|
|
||||||
Surfaces_set sset;
|
|
||||||
envelope_find_unique_surfaces_set(arr, sset);
|
|
||||||
|
|
||||||
for(Surfaces_set_it it = sset.begin(); it != sset.end(); ++it)
|
|
||||||
{
|
|
||||||
*o = *it;
|
|
||||||
++o;
|
|
||||||
}
|
|
||||||
return o;
|
|
||||||
}
|
|
||||||
|
|
||||||
template <class MinimizationDiagram_2, class Surfaces_set>
|
|
||||||
void envelope_find_unique_surfaces_set(MinimizationDiagram_2& arr, Surfaces_set& sset)
|
|
||||||
{
|
|
||||||
typedef MinimizationDiagram_2 Minimization_diagram_2;
|
|
||||||
typedef typename Minimization_diagram_2::Traits_2 Traits_2;
|
|
||||||
typedef typename Traits_2::Xy_monotone_surface_3 Xy_monotone_surface_3;
|
|
||||||
|
|
||||||
typedef typename Minimization_diagram_2::Halfedge_iterator Halfedge_iterator;
|
|
||||||
typedef typename Minimization_diagram_2::Face_iterator Face_iterator;
|
|
||||||
typedef typename Minimization_diagram_2::Vertex_iterator Vertex_iterator;
|
|
||||||
typedef typename Minimization_diagram_2::Dcel::Face_data_iterator Data_iterator;
|
|
||||||
|
|
||||||
Data_iterator di;
|
|
||||||
// vertices
|
|
||||||
Vertex_iterator vi = arr.vertices_begin();
|
|
||||||
for(; vi != arr.vertices_end(); ++vi)
|
|
||||||
{
|
|
||||||
di = vi->begin_data();
|
|
||||||
for(; di != vi->end_data(); ++di)
|
|
||||||
sset.insert(*di);
|
|
||||||
}
|
|
||||||
// edges
|
|
||||||
Halfedge_iterator hi = arr.halfedges_begin();
|
|
||||||
for(; hi != arr.halfedges_end(); ++hi)
|
|
||||||
{
|
|
||||||
di = hi->begin_data();
|
|
||||||
for(; di != hi->end_data(); ++di)
|
|
||||||
sset.insert(*di);
|
|
||||||
}
|
|
||||||
|
|
||||||
// faces
|
|
||||||
Face_iterator fi = arr.faces_begin();
|
|
||||||
for(; fi != arr.faces_end(); ++fi)
|
|
||||||
{
|
|
||||||
di = fi->begin_data();
|
|
||||||
for(; di != fi->end_data(); ++di)
|
|
||||||
sset.insert(*di);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
CGAL_END_NAMESPACE
|
|
||||||
|
|
||||||
#endif
|
|
||||||
Loading…
Reference in New Issue