213 lines
7.1 KiB
C++
Executable File
213 lines
7.1 KiB
C++
Executable File
// Copyright (c) 2013 Tel-Aviv University (Israel).
|
|
// All rights reserved.
|
|
//
|
|
// This file is part of CGAL (www.cgal.org).
|
|
// You can redistribute it and/or modify it under the terms of the GNU
|
|
// General Public License as published by the Free Software Foundation,
|
|
// either version 3 of the License, or (at your option) any later version.
|
|
//
|
|
// 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$
|
|
// SPDX-License-Identifier: GPL-3.0+
|
|
//
|
|
// Author(s) : Efi Fogel <efifogel@gmail.com>
|
|
|
|
#ifndef CGAL_POLYGON_TRIANGULATION_DECOMPOSITION_2_H
|
|
#define CGAL_POLYGON_TRIANGULATION_DECOMPOSITION_2_H
|
|
|
|
#include <CGAL/license/Minkowski_sum_2.h>
|
|
|
|
|
|
#include <CGAL/General_polygon_set_2.h>
|
|
|
|
#include <CGAL/Constrained_Delaunay_triangulation_2.h>
|
|
#include <CGAL/Triangulation_face_base_with_info_2.h>
|
|
#include <CGAL/Polygon_2.h>
|
|
#include <CGAL/Polygon_with_holes_2.h>
|
|
#include <iostream>
|
|
#include <vector>
|
|
#include <list>
|
|
|
|
namespace CGAL {
|
|
|
|
/*! \class Polygon_triangulation_decomposition Polygon_triangulation_decomposition.h
|
|
* Constrained triangulation decomposition strategy.
|
|
*/
|
|
template <typename Kernel_,
|
|
typename Container_ = std::vector<typename Kernel_::Point_2> >
|
|
class Polygon_triangulation_decomposition_2 {
|
|
public:
|
|
typedef Kernel_ Kernel;
|
|
typedef Container_ Container;
|
|
|
|
typedef CGAL::Polygon_2<Kernel, Container> Polygon_2;
|
|
typedef CGAL::Polygon_with_holes_2<Kernel, Container> Polygon_with_holes_2;
|
|
|
|
private:
|
|
struct Face_info {
|
|
Face_info() {}
|
|
int nesting_level;
|
|
bool in_domain() { return nesting_level % 2 == 1; }
|
|
};
|
|
|
|
// Triangulation types
|
|
typedef CGAL::Triangulation_vertex_base_2<Kernel> VB;
|
|
typedef CGAL::Triangulation_face_base_with_info_2<Face_info, Kernel> FBI;
|
|
typedef CGAL::Constrained_triangulation_face_base_2<Kernel, FBI> FB;
|
|
typedef CGAL::Triangulation_data_structure_2<VB, FB> TDS;
|
|
typedef CGAL::Exact_predicates_tag Itag;
|
|
typedef CGAL::Constrained_Delaunay_triangulation_2<Kernel, TDS, Itag> CDT;
|
|
|
|
public:
|
|
/*! Default constructor. */
|
|
Polygon_triangulation_decomposition_2() {}
|
|
|
|
// Destructor
|
|
~Polygon_triangulation_decomposition_2() {}
|
|
|
|
/*! Decompose a polygon-with-holes into convex sub-polygons.
|
|
* \param pgn The input polygon.
|
|
* \param oi An output iterator of convex polygons.
|
|
* \return A past-the-end iterator for the sub-polygons.
|
|
*/
|
|
template <typename OutputIterator_>
|
|
OutputIterator_ operator()(const Polygon_2& pgm, OutputIterator_ oi) const
|
|
{
|
|
CDT cdt;
|
|
|
|
// Insert boundary:
|
|
insert_polygon(cdt, pgm);
|
|
|
|
// Mark facets that are inside the domain bounded by the polygon
|
|
mark_domains(cdt);
|
|
|
|
typename CDT::Finite_faces_iterator fit;
|
|
for (fit = cdt.finite_faces_begin(); fit != cdt.finite_faces_end(); ++fit) {
|
|
if (! fit->info().in_domain()) continue;
|
|
typename CDT::Vertex_handle vh0 = fit->vertex(0);
|
|
typename CDT::Vertex_handle vh1 = fit->vertex(1);
|
|
typename CDT::Vertex_handle vh2 = fit->vertex(2);
|
|
Polygon_2 pgn;
|
|
pgn.push_back(vh0->point());
|
|
pgn.push_back(vh1->point());
|
|
pgn.push_back(vh2->point());
|
|
*oi++ = pgn;
|
|
}
|
|
return oi;
|
|
}
|
|
|
|
/*! Decompose a polygon-with-holes into convex sub-polygons.
|
|
* \param pgn The input polygon.
|
|
* \param oi An output iterator of convex polygons.
|
|
* \return A past-the-end iterator for the sub-polygons.
|
|
*/
|
|
template <typename OutputIterator_>
|
|
OutputIterator_
|
|
operator()(const Polygon_with_holes_2& pgm, OutputIterator_ oi) const
|
|
{
|
|
CDT cdt;
|
|
|
|
// Insert outer boundary:
|
|
const Polygon_2& outer_pgn = pgm.outer_boundary();
|
|
insert_polygon(cdt, outer_pgn);
|
|
|
|
// Insert holes:
|
|
typename Polygon_with_holes_2::Hole_const_iterator ith;
|
|
for (ith = pgm.holes_begin(); ith != pgm.holes_end(); ++ith)
|
|
insert_polygon(cdt, *ith);
|
|
|
|
// Mark facets that are inside the domain bounded by the polygon
|
|
mark_domains(cdt);
|
|
|
|
typename CDT::Finite_faces_iterator fit;
|
|
for (fit = cdt.finite_faces_begin(); fit != cdt.finite_faces_end(); ++fit) {
|
|
if (! fit->info().in_domain()) continue;
|
|
typename CDT::Vertex_handle vh0 = fit->vertex(0);
|
|
typename CDT::Vertex_handle vh1 = fit->vertex(1);
|
|
typename CDT::Vertex_handle vh2 = fit->vertex(2);
|
|
Polygon_2 pgn;
|
|
pgn.push_back(vh0->point());
|
|
pgn.push_back(vh1->point());
|
|
pgn.push_back(vh2->point());
|
|
*oi++ = pgn;
|
|
}
|
|
return oi;
|
|
}
|
|
|
|
private:
|
|
void mark_domains(CDT& cdt, typename CDT::Face_handle start, int index,
|
|
std::list<typename CDT::Edge>& border) const
|
|
{
|
|
if (start->info().nesting_level != -1) return;
|
|
std::list<typename CDT::Face_handle> queue;
|
|
queue.push_back(start);
|
|
while (! queue.empty()) {
|
|
typename CDT::Face_handle fh = queue.front();
|
|
queue.pop_front();
|
|
if (fh->info().nesting_level == -1) {
|
|
fh->info().nesting_level = index;
|
|
for (int i = 0; i < 3; i++) {
|
|
typename CDT::Edge e(fh,i);
|
|
typename CDT::Face_handle n = fh->neighbor(i);
|
|
if (n->info().nesting_level == -1) {
|
|
if (cdt.is_constrained(e)) border.push_back(e);
|
|
else queue.push_back(n);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Explore set of facets connected with non constrained edges,
|
|
// and attribute to each such set a nesting level.
|
|
// We start from facets incident to the infinite vertex, with a nesting
|
|
// level of 0. Then we recursively consider the non-explored facets incident
|
|
// to constrained edges bounding the former set and increase the nesting
|
|
// level by 1.
|
|
// Facets in the domain are those with an odd nesting level.
|
|
void mark_domains(CDT& cdt) const
|
|
{
|
|
typename CDT::All_faces_iterator it;
|
|
for (it = cdt.all_faces_begin(); it != cdt.all_faces_end(); ++it)
|
|
it->info().nesting_level = -1;
|
|
|
|
std::list<typename CDT::Edge> border;
|
|
mark_domains(cdt, cdt.infinite_face(), 0, border);
|
|
while (! border.empty()) {
|
|
typename CDT::Edge e = border.front();
|
|
border.pop_front();
|
|
typename CDT::Face_handle n = e.first->neighbor(e.second);
|
|
if (n->info().nesting_level == -1)
|
|
mark_domains(cdt, n, e.first->info().nesting_level+1, border);
|
|
}
|
|
}
|
|
|
|
template <typename Polygon_>
|
|
void insert_polygon(CDT& cdt, const Polygon_& pgn) const
|
|
{
|
|
typedef Polygon_ Polygon_2;
|
|
if (pgn.is_empty()) return;
|
|
typedef typename Polygon_2::Vertex_circulator Vertex_circulator;
|
|
|
|
Vertex_circulator v_start = pgn.vertices_circulator();
|
|
typename CDT::Vertex_handle vt_prev = cdt.insert(*v_start);
|
|
Vertex_circulator v_curr = v_start;
|
|
do {
|
|
++v_curr;
|
|
typename CDT::Vertex_handle vt_curr = cdt.insert(*v_curr);
|
|
cdt.insert_constraint(vt_prev, vt_curr);
|
|
vt_prev = vt_curr;
|
|
} while (v_curr != v_start);
|
|
}
|
|
};
|
|
|
|
} //namespace CGAL
|
|
|
|
#endif
|