graph_triangulation.cc 3.59 KB
Newer Older
1 2
// graph-tool -- a general graph modification and manipulation thingy
//
Tiago Peixoto's avatar
Tiago Peixoto committed
3
// Copyright (C) 2007-2012 Tiago de Paula Peixoto <tiago@skewed.de>
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
//
// This program is free software; 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.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.

//  As a special exception, you have permission to link this program
//  with the CGAL library and distribute executables, as long as you
//  follow the requirements of the GNU GPL in regard to all of the
//  software in the executable aside from CGAL.

23 24 25 26 27
#if (GCC_VERSION < 40400)
#   define CGAL_CFG_NO_TR1_ARRAY
#   define CGAL_CFG_NO_TR1_TUPLE
#endif

28
#include <CGAL/version.h>
29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
#include <CGAL/Triangulation_3.h>
#include <CGAL/Delaunay_triangulation_3.h>
typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
typedef CGAL::Triangulation_3<Kernel> SimpleTriangulation;
typedef CGAL::Delaunay_triangulation_3<Kernel> DelaunayTriangulation;

namespace std
{
bool operator==(const SimpleTriangulation::Vertex& a,
                const SimpleTriangulation::Vertex& b)
{
    return a.point() == b.point();
}
}

45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61
// periodic triangulation is only available in more recent versions of CGAL
#if (CGAL_VERSION_NR >= 1030500000)
#include <CGAL/Periodic_3_triangulation_traits_3.h>
#include <CGAL/Periodic_3_Delaunay_triangulation_3.h>
typedef CGAL::Periodic_3_triangulation_traits_3<Kernel> GT;
typedef CGAL::Periodic_3_Delaunay_triangulation_3<GT>
    PeriodicDelaunayTriangulation;
namespace std
{
bool operator==(const PeriodicDelaunayTriangulation::Vertex& a,
                const PeriodicDelaunayTriangulation::Vertex& b)
{
    return a.point() == b.point();
}
}
#endif

62
#include "graph.hh"
63
#include "graph_triangulation.hh"
64 65 66 67 68 69 70 71 72
#include "graph_util.hh"
#include "graph_filtering.hh"
#include "numpy_bind.hh"

using namespace std;
using namespace boost;
using namespace graph_tool;

void triangulation(GraphInterface& gi, python::object points, boost::any pos,
73
                   string type, bool periodic)
74 75 76 77 78 79 80 81
{
    UndirectedAdaptor<GraphInterface::multigraph_t> g(gi.GetGraph());
    multi_array_ref<double,2> points_array = get_array<double,2>(points);
    typedef property_map_type::apply
        <vector<double>, GraphInterface::vertex_index_map_t>::type pos_type_t;
    pos_type_t pos_map = any_cast<pos_type_t>(pos);

    if (type == "simple")
82
    {
83
        get_triangulation<SimpleTriangulation>()(g, points_array, pos_map);
84
    }
85
    else if (type == "delaunay")
86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
    {
        if (!periodic)
        {
            get_triangulation<DelaunayTriangulation>()(g, points_array,
                                                       pos_map);
        }
        else
        {
#if (CGAL_VERSION_NR >= 1030500000)
            get_triangulation<PeriodicDelaunayTriangulation>()(g, points_array,
                                                               pos_map);
#else
            throw ValueException("Periodic Delaunay triangulation is only "
                                 "available with versions of CGAL newer than "
                                 "3.5.0.");
#endif
        }
    }
104 105
    gi.ReIndexEdges();
}