Prebuilt Boost for Android
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1015 lines
32 KiB

//=======================================================================
// Copyright 2009 Trustees of Indiana University.
// Authors: Michael Hansen, Andrew Lumsdaine
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//=======================================================================
#ifndef BOOST_GRAPH_GRID_GRAPH_HPP
#define BOOST_GRAPH_GRID_GRAPH_HPP
#include <cmath>
#include <functional>
#include <numeric>
#include <boost/array.hpp>
#include <boost/bind.hpp>
#include <boost/limits.hpp>
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/properties.hpp>
#include <boost/iterator/counting_iterator.hpp>
#include <boost/iterator/transform_iterator.hpp>
#include <boost/property_map/property_map.hpp>
#define BOOST_GRID_GRAPH_TEMPLATE_PARAMS \
std::size_t DimensionsT, typename VertexIndexT, \
typename EdgeIndexT
#define BOOST_GRID_GRAPH_TYPE \
grid_graph<DimensionsT, VertexIndexT, EdgeIndexT>
#define BOOST_GRID_GRAPH_TRAITS_T \
typename graph_traits<BOOST_GRID_GRAPH_TYPE >
namespace boost {
// Class prototype for grid_graph
template<BOOST_GRID_GRAPH_TEMPLATE_PARAMS>
class grid_graph;
//===================
// Index Property Map
//===================
template <typename Graph,
typename Descriptor,
typename Index>
struct grid_graph_index_map {
public:
typedef Index value_type;
typedef Index reference_type;
typedef reference_type reference;
typedef Descriptor key_type;
typedef readable_property_map_tag category;
grid_graph_index_map() { }
grid_graph_index_map(const Graph& graph) :
m_graph(&graph) { }
value_type operator[](key_type key) const {
return (m_graph->index_of(key));
}
friend inline Index
get(const grid_graph_index_map<Graph, Descriptor, Index>& index_map,
const typename grid_graph_index_map<Graph, Descriptor, Index>::key_type& key)
{
return (index_map[key]);
}
protected:
const Graph* m_graph;
};
template<BOOST_GRID_GRAPH_TEMPLATE_PARAMS>
struct property_map<BOOST_GRID_GRAPH_TYPE, vertex_index_t> {
typedef grid_graph_index_map<BOOST_GRID_GRAPH_TYPE,
BOOST_GRID_GRAPH_TRAITS_T::vertex_descriptor,
BOOST_GRID_GRAPH_TRAITS_T::vertices_size_type> type;
typedef type const_type;
};
template<BOOST_GRID_GRAPH_TEMPLATE_PARAMS>
struct property_map<BOOST_GRID_GRAPH_TYPE, edge_index_t> {
typedef grid_graph_index_map<BOOST_GRID_GRAPH_TYPE,
BOOST_GRID_GRAPH_TRAITS_T::edge_descriptor,
BOOST_GRID_GRAPH_TRAITS_T::edges_size_type> type;
typedef type const_type;
};
//==========================
// Reverse Edge Property Map
//==========================
template <typename Descriptor>
struct grid_graph_reverse_edge_map {
public:
typedef Descriptor value_type;
typedef Descriptor reference_type;
typedef reference_type reference;
typedef Descriptor key_type;
typedef readable_property_map_tag category;
grid_graph_reverse_edge_map() { }
value_type operator[](const key_type& key) const {
return (value_type(key.second, key.first));
}
friend inline Descriptor
get(const grid_graph_reverse_edge_map<Descriptor>& rev_map,
const typename grid_graph_reverse_edge_map<Descriptor>::key_type& key)
{
return (rev_map[key]);
}
};
template<BOOST_GRID_GRAPH_TEMPLATE_PARAMS>
struct property_map<BOOST_GRID_GRAPH_TYPE, edge_reverse_t> {
typedef grid_graph_reverse_edge_map<BOOST_GRID_GRAPH_TRAITS_T::edge_descriptor> type;
typedef type const_type;
};
//=================
// Function Objects
//=================
namespace detail {
// vertex_at
template <typename Graph>
struct grid_graph_vertex_at {
typedef typename graph_traits<Graph>::vertex_descriptor result_type;
grid_graph_vertex_at() : m_graph(0) {}
grid_graph_vertex_at(const Graph* graph) :
m_graph(graph) { }
result_type
operator()
(typename graph_traits<Graph>::vertices_size_type vertex_index) const {
return (vertex(vertex_index, *m_graph));
}
private:
const Graph* m_graph;
};
// out_edge_at
template <typename Graph>
struct grid_graph_out_edge_at {
private:
typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor;
public:
typedef typename graph_traits<Graph>::edge_descriptor result_type;
grid_graph_out_edge_at() : m_vertex(), m_graph(0) {}
grid_graph_out_edge_at(vertex_descriptor source_vertex,
const Graph* graph) :
m_vertex(source_vertex),
m_graph(graph) { }
result_type
operator()
(typename graph_traits<Graph>::degree_size_type out_edge_index) const {
return (out_edge_at(m_vertex, out_edge_index, *m_graph));
}
private:
vertex_descriptor m_vertex;
const Graph* m_graph;
};
// in_edge_at
template <typename Graph>
struct grid_graph_in_edge_at {
private:
typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor;
public:
typedef typename graph_traits<Graph>::edge_descriptor result_type;
grid_graph_in_edge_at() : m_vertex(), m_graph(0) {}
grid_graph_in_edge_at(vertex_descriptor target_vertex,
const Graph* graph) :
m_vertex(target_vertex),
m_graph(graph) { }
result_type
operator()
(typename graph_traits<Graph>::degree_size_type in_edge_index) const {
return (in_edge_at(m_vertex, in_edge_index, *m_graph));
}
private:
vertex_descriptor m_vertex;
const Graph* m_graph;
};
// edge_at
template <typename Graph>
struct grid_graph_edge_at {
typedef typename graph_traits<Graph>::edge_descriptor result_type;
grid_graph_edge_at() : m_graph(0) {}
grid_graph_edge_at(const Graph* graph) :
m_graph(graph) { }
result_type
operator()
(typename graph_traits<Graph>::edges_size_type edge_index) const {
return (edge_at(edge_index, *m_graph));
}
private:
const Graph* m_graph;
};
// adjacent_vertex_at
template <typename Graph>
struct grid_graph_adjacent_vertex_at {
public:
typedef typename graph_traits<Graph>::vertex_descriptor result_type;
grid_graph_adjacent_vertex_at(result_type source_vertex,
const Graph* graph) :
m_vertex(source_vertex),
m_graph(graph) { }
result_type
operator()
(typename graph_traits<Graph>::degree_size_type adjacent_index) const {
return (target(out_edge_at(m_vertex, adjacent_index, *m_graph), *m_graph));
}
private:
result_type m_vertex;
const Graph* m_graph;
};
} // namespace detail
//===========
// Grid Graph
//===========
template <std::size_t Dimensions,
typename VertexIndex = std::size_t,
typename EdgeIndex = VertexIndex>
class grid_graph {
private:
typedef boost::array<bool, Dimensions> WrapDimensionArray;
grid_graph() { };
public:
typedef grid_graph<Dimensions, VertexIndex, EdgeIndex> type;
// sizes
typedef VertexIndex vertices_size_type;
typedef EdgeIndex edges_size_type;
typedef EdgeIndex degree_size_type;
// descriptors
typedef boost::array<VertexIndex, Dimensions> vertex_descriptor;
typedef std::pair<vertex_descriptor, vertex_descriptor> edge_descriptor;
// vertex_iterator
typedef counting_iterator<vertices_size_type> vertex_index_iterator;
typedef detail::grid_graph_vertex_at<type> vertex_function;
typedef transform_iterator<vertex_function, vertex_index_iterator> vertex_iterator;
// edge_iterator
typedef counting_iterator<edges_size_type> edge_index_iterator;
typedef detail::grid_graph_edge_at<type> edge_function;
typedef transform_iterator<edge_function, edge_index_iterator> edge_iterator;
// out_edge_iterator
typedef counting_iterator<degree_size_type> degree_iterator;
typedef detail::grid_graph_out_edge_at<type> out_edge_function;
typedef transform_iterator<out_edge_function, degree_iterator> out_edge_iterator;
// in_edge_iterator
typedef detail::grid_graph_in_edge_at<type> in_edge_function;
typedef transform_iterator<in_edge_function, degree_iterator> in_edge_iterator;
// adjacency_iterator
typedef detail::grid_graph_adjacent_vertex_at<type> adjacent_vertex_function;
typedef transform_iterator<adjacent_vertex_function, degree_iterator> adjacency_iterator;
// categories
typedef directed_tag directed_category;
typedef disallow_parallel_edge_tag edge_parallel_category;
struct traversal_category : virtual public incidence_graph_tag,
virtual public adjacency_graph_tag,
virtual public vertex_list_graph_tag,
virtual public edge_list_graph_tag,
virtual public bidirectional_graph_tag,
virtual public adjacency_matrix_tag { };
static inline vertex_descriptor null_vertex()
{
vertex_descriptor maxed_out_vertex;
std::fill(maxed_out_vertex.begin(), maxed_out_vertex.end(),
(std::numeric_limits<vertices_size_type>::max)());
return (maxed_out_vertex);
}
// Constructor that defaults to no wrapping for all dimensions.
grid_graph(vertex_descriptor dimension_lengths) :
m_dimension_lengths(dimension_lengths) {
std::fill(m_wrap_dimension.begin(),
m_wrap_dimension.end(), false);
precalculate();
}
// Constructor that allows for wrapping to be specified for all
// dimensions at once.
grid_graph(vertex_descriptor dimension_lengths,
bool wrap_all_dimensions) :
m_dimension_lengths(dimension_lengths) {
std::fill(m_wrap_dimension.begin(),
m_wrap_dimension.end(),
wrap_all_dimensions);
precalculate();
}
// Constructor that allows for individual dimension wrapping to be
// specified.
grid_graph(vertex_descriptor dimension_lengths,
WrapDimensionArray wrap_dimension) :
m_dimension_lengths(dimension_lengths),
m_wrap_dimension(wrap_dimension) {
precalculate();
}
// Returns the number of dimensions in the graph
inline std::size_t dimensions() const {
return (Dimensions);
}
// Returns the length of dimension [dimension_index]
inline vertices_size_type length(std::size_t dimension) const {
return (m_dimension_lengths[dimension]);
}
// Returns a value indicating if dimension [dimension_index] wraps
inline bool wrapped(std::size_t dimension) const {
return (m_wrap_dimension[dimension]);
}
// Gets the vertex that is [distance] units ahead of [vertex] in
// dimension [dimension_index].
vertex_descriptor next
(vertex_descriptor vertex,
std::size_t dimension_index,
vertices_size_type distance = 1) const {
vertices_size_type new_position =
vertex[dimension_index] + distance;
if (wrapped(dimension_index)) {
new_position %= length(dimension_index);
}
else {
// Stop at the end of this dimension if necessary.
new_position =
(std::min)(new_position,
vertices_size_type(length(dimension_index) - 1));
}
vertex[dimension_index] = new_position;
return (vertex);
}
// Gets the vertex that is [distance] units behind [vertex] in
// dimension [dimension_index].
vertex_descriptor previous
(vertex_descriptor vertex,
std::size_t dimension_index,
vertices_size_type distance = 1) const {
// We're assuming that vertices_size_type is unsigned, so we
// need to be careful about the math.
vertex[dimension_index] =
(distance > vertex[dimension_index]) ?
(wrapped(dimension_index) ?
(length(dimension_index) - (distance % length(dimension_index))) : 0) :
vertex[dimension_index] - distance;
return (vertex);
}
protected:
// Returns the number of vertices in the graph
inline vertices_size_type num_vertices() const {
return (m_num_vertices);
}
// Returns the number of edges in the graph
inline edges_size_type num_edges() const {
return (m_num_edges);
}
// Returns the number of edges in dimension [dimension_index]
inline edges_size_type num_edges
(std::size_t dimension_index) const {
return (m_edge_count[dimension_index]);
}
// Returns the index of [vertex] (See also vertex_at)
vertices_size_type index_of(vertex_descriptor vertex) const {
vertices_size_type vertex_index = 0;
vertices_size_type index_multiplier = 1;
for (std::size_t dimension_index = 0;
dimension_index < Dimensions;
++dimension_index) {
vertex_index += (vertex[dimension_index] * index_multiplier);
index_multiplier *= length(dimension_index);
}
return (vertex_index);
}
// Returns the vertex whose index is [vertex_index] (See also
// index_of(vertex_descriptor))
vertex_descriptor vertex_at
(vertices_size_type vertex_index) const {
boost::array<vertices_size_type, Dimensions> vertex;
vertices_size_type index_divider = 1;
for (std::size_t dimension_index = 0;
dimension_index < Dimensions;
++dimension_index) {
vertex[dimension_index] = (vertex_index / index_divider) %
length(dimension_index);
index_divider *= length(dimension_index);
}
return (vertex);
}
// Returns the edge whose index is [edge_index] (See also
// index_of(edge_descriptor)). NOTE: The index mapping is
// dependent upon dimension wrapping.
edge_descriptor edge_at(edges_size_type edge_index) const {
// Edge indices are sorted into bins by dimension
std::size_t dimension_index = 0;
edges_size_type dimension_edges = num_edges(0);
while (edge_index >= dimension_edges) {
edge_index -= dimension_edges;
++dimension_index;
dimension_edges = num_edges(dimension_index);
}
vertex_descriptor vertex_source, vertex_target;
bool is_forward = ((edge_index / (num_edges(dimension_index) / 2)) == 0);
if (wrapped(dimension_index)) {
vertex_source = vertex_at(edge_index % num_vertices());
vertex_target = is_forward ?
next(vertex_source, dimension_index) :
previous(vertex_source, dimension_index);
}
else {
// Dimensions can wrap arbitrarily, so an index needs to be
// computed in a more complex manner. This is done by
// grouping the edges for each dimension together into "bins"
// and considering [edge_index] as an offset into the bin.
// Each bin consists of two parts: the "forward" looking edges
// and the "backward" looking edges for the dimension.
edges_size_type vertex_offset = edge_index % num_edges(dimension_index);
// Consider vertex_offset an index into the graph's vertex
// space but with the dimension [dimension_index] reduced in
// size by one.
vertices_size_type index_divider = 1;
for (std::size_t dimension_index_iter = 0;
dimension_index_iter < Dimensions;
++dimension_index_iter) {
std::size_t dimension_length = (dimension_index_iter == dimension_index) ?
length(dimension_index_iter) - 1 :
length(dimension_index_iter);
vertex_source[dimension_index_iter] = (vertex_offset / index_divider) %
dimension_length;
index_divider *= dimension_length;
}
if (is_forward) {
vertex_target = next(vertex_source, dimension_index);
}
else {
// Shift forward one more unit in the dimension for backward
// edges since the algorithm above will leave us one behind.
vertex_target = vertex_source;
++vertex_source[dimension_index];
}
} // if (wrapped(dimension_index))
return (std::make_pair(vertex_source, vertex_target));
}
// Returns the index for [edge] (See also edge_at)
edges_size_type index_of(edge_descriptor edge) const {
vertex_descriptor source_vertex = source(edge, *this);
vertex_descriptor target_vertex = target(edge, *this);
BOOST_ASSERT (source_vertex != target_vertex);
// Determine the dimension where the source and target vertices
// differ (should only be one if this is a valid edge).
std::size_t different_dimension_index = 0;
while (source_vertex[different_dimension_index] ==
target_vertex[different_dimension_index]) {
++different_dimension_index;
}
edges_size_type edge_index = 0;
// Offset the edge index into the appropriate "bin" (see edge_at
// for a more in-depth description).
for (std::size_t dimension_index = 0;
dimension_index < different_dimension_index;
++dimension_index) {
edge_index += num_edges(dimension_index);
}
// Get the position of both vertices in the differing dimension.
vertices_size_type source_position = source_vertex[different_dimension_index];
vertices_size_type target_position = target_vertex[different_dimension_index];
// Determine if edge is forward or backward
bool is_forward = true;
if (wrapped(different_dimension_index)) {
// If the dimension is wrapped, an edge is going backward if
// either A: its target precedes the source in the differing
// dimension and the vertices are adjacent or B: its source
// precedes the target and they're not adjacent.
if (((target_position < source_position) &&
((source_position - target_position) == 1)) ||
((source_position < target_position) &&
((target_position - source_position) > 1))) {
is_forward = false;
}
}
else if (target_position < source_position) {
is_forward = false;
}
// "Backward" edges are in the second half of the bin.
if (!is_forward) {
edge_index += (num_edges(different_dimension_index) / 2);
}
// Finally, apply the vertex offset
if (wrapped(different_dimension_index)) {
edge_index += index_of(source_vertex);
}
else {
vertices_size_type index_multiplier = 1;
if (!is_forward) {
--source_vertex[different_dimension_index];
}
for (std::size_t dimension_index = 0;
dimension_index < Dimensions;
++dimension_index) {
edge_index += (source_vertex[dimension_index] * index_multiplier);
index_multiplier *= (dimension_index == different_dimension_index) ?
length(dimension_index) - 1 :
length(dimension_index);
}
}
return (edge_index);
}
// Returns the number of out-edges for [vertex]
degree_size_type out_degree(vertex_descriptor vertex) const {
degree_size_type out_edge_count = 0;
for (std::size_t dimension_index = 0;
dimension_index < Dimensions;
++dimension_index) {
// If the vertex is on the edge of this dimension, then its
// number of out edges is dependent upon whether the dimension
// wraps or not.
if ((vertex[dimension_index] == 0) ||
(vertex[dimension_index] == (length(dimension_index) - 1))) {
out_edge_count += (wrapped(dimension_index) ? 2 : 1);
}
else {
// Next and previous edges, regardless or wrapping
out_edge_count += 2;
}
}
return (out_edge_count);
}
// Returns an out-edge for [vertex] by index. Indices are in the
// range [0, out_degree(vertex)).
edge_descriptor out_edge_at
(vertex_descriptor vertex,
degree_size_type out_edge_index) const {
edges_size_type edges_left = out_edge_index + 1;
std::size_t dimension_index = 0;
bool is_forward = false;
// Walks the out edges of [vertex] and accommodates for dimension
// wrapping.
while (edges_left > 0) {
if (!wrapped(dimension_index)) {
if (!is_forward && (vertex[dimension_index] == 0)) {
is_forward = true;
continue;
}
else if (is_forward &&
(vertex[dimension_index] == (length(dimension_index) - 1))) {
is_forward = false;
++dimension_index;
continue;
}
}
--edges_left;
if (edges_left > 0) {
is_forward = !is_forward;
if (!is_forward) {
++dimension_index;
}
}
}
return (std::make_pair(vertex, is_forward ?
next(vertex, dimension_index) :
previous(vertex, dimension_index)));
}
// Returns the number of in-edges for [vertex]
inline degree_size_type in_degree(vertex_descriptor vertex) const {
return (out_degree(vertex));
}
// Returns an in-edge for [vertex] by index. Indices are in the
// range [0, in_degree(vertex)).
edge_descriptor in_edge_at
(vertex_descriptor vertex,
edges_size_type in_edge_index) const {
edge_descriptor out_edge = out_edge_at(vertex, in_edge_index);
return (std::make_pair(target(out_edge, *this), source(out_edge, *this)));
}
// Pre-computes the number of vertices and edges
void precalculate() {
m_num_vertices =
std::accumulate(m_dimension_lengths.begin(),
m_dimension_lengths.end(),
vertices_size_type(1),
std::multiplies<vertices_size_type>());
// Calculate number of edges in each dimension
m_num_edges = 0;
for (std::size_t dimension_index = 0;
dimension_index < Dimensions;
++dimension_index) {
if (wrapped(dimension_index)) {
m_edge_count[dimension_index] = num_vertices() * 2;
}
else {
m_edge_count[dimension_index] =
(num_vertices() - (num_vertices() / length(dimension_index))) * 2;
}
m_num_edges += num_edges(dimension_index);
}
}
const vertex_descriptor m_dimension_lengths;
WrapDimensionArray m_wrap_dimension;
vertices_size_type m_num_vertices;
boost::array<edges_size_type, Dimensions> m_edge_count;
edges_size_type m_num_edges;
public:
//================
// VertexListGraph
//================
friend inline std::pair<typename type::vertex_iterator,
typename type::vertex_iterator>
vertices(const type& graph) {
typedef typename type::vertex_iterator vertex_iterator;
typedef typename type::vertex_function vertex_function;
typedef typename type::vertex_index_iterator vertex_index_iterator;
return (std::make_pair
(vertex_iterator(vertex_index_iterator(0),
vertex_function(&graph)),
vertex_iterator(vertex_index_iterator(graph.num_vertices()),
vertex_function(&graph))));
}
friend inline typename type::vertices_size_type
num_vertices(const type& graph) {
return (graph.num_vertices());
}
friend inline typename type::vertex_descriptor
vertex(typename type::vertices_size_type vertex_index,
const type& graph) {
return (graph.vertex_at(vertex_index));
}
//===============
// IncidenceGraph
//===============
friend inline std::pair<typename type::out_edge_iterator,
typename type::out_edge_iterator>
out_edges(typename type::vertex_descriptor vertex,
const type& graph) {
typedef typename type::degree_iterator degree_iterator;
typedef typename type::out_edge_function out_edge_function;
typedef typename type::out_edge_iterator out_edge_iterator;
return (std::make_pair
(out_edge_iterator(degree_iterator(0),
out_edge_function(vertex, &graph)),
out_edge_iterator(degree_iterator(graph.out_degree(vertex)),
out_edge_function(vertex, &graph))));
}
friend inline typename type::degree_size_type
out_degree
(typename type::vertex_descriptor vertex,
const type& graph) {
return (graph.out_degree(vertex));
}
friend inline typename type::edge_descriptor
out_edge_at(typename type::vertex_descriptor vertex,
typename type::degree_size_type out_edge_index,
const type& graph) {
return (graph.out_edge_at(vertex, out_edge_index));
}
//===============
// AdjacencyGraph
//===============
friend typename std::pair<typename type::adjacency_iterator,
typename type::adjacency_iterator>
adjacent_vertices (typename type::vertex_descriptor vertex,
const type& graph) {
typedef typename type::degree_iterator degree_iterator;
typedef typename type::adjacent_vertex_function adjacent_vertex_function;
typedef typename type::adjacency_iterator adjacency_iterator;
return (std::make_pair
(adjacency_iterator(degree_iterator(0),
adjacent_vertex_function(vertex, &graph)),
adjacency_iterator(degree_iterator(graph.out_degree(vertex)),
adjacent_vertex_function(vertex, &graph))));
}
//==============
// EdgeListGraph
//==============
friend inline typename type::edges_size_type
num_edges(const type& graph) {
return (graph.num_edges());
}
friend inline typename type::edge_descriptor
edge_at(typename type::edges_size_type edge_index,
const type& graph) {
return (graph.edge_at(edge_index));
}
friend inline std::pair<typename type::edge_iterator,
typename type::edge_iterator>
edges(const type& graph) {
typedef typename type::edge_index_iterator edge_index_iterator;
typedef typename type::edge_function edge_function;
typedef typename type::edge_iterator edge_iterator;
return (std::make_pair
(edge_iterator(edge_index_iterator(0),
edge_function(&graph)),
edge_iterator(edge_index_iterator(graph.num_edges()),
edge_function(&graph))));
}
//===================
// BiDirectionalGraph
//===================
friend inline std::pair<typename type::in_edge_iterator,
typename type::in_edge_iterator>
in_edges(typename type::vertex_descriptor vertex,
const type& graph) {
typedef typename type::in_edge_function in_edge_function;
typedef typename type::degree_iterator degree_iterator;
typedef typename type::in_edge_iterator in_edge_iterator;
return (std::make_pair
(in_edge_iterator(degree_iterator(0),
in_edge_function(vertex, &graph)),
in_edge_iterator(degree_iterator(graph.in_degree(vertex)),
in_edge_function(vertex, &graph))));
}
friend inline typename type::degree_size_type
in_degree (typename type::vertex_descriptor vertex,
const type& graph) {
return (graph.in_degree(vertex));
}
friend inline typename type::degree_size_type
degree (typename type::vertex_descriptor vertex,
const type& graph) {
return (graph.out_degree(vertex) * 2);
}
friend inline typename type::edge_descriptor
in_edge_at(typename type::vertex_descriptor vertex,
typename type::degree_size_type in_edge_index,
const type& graph) {
return (graph.in_edge_at(vertex, in_edge_index));
}
//==================
// Adjacency Matrix
//==================
friend std::pair<typename type::edge_descriptor, bool>
edge (typename type::vertex_descriptor source_vertex,
typename type::vertex_descriptor destination_vertex,
const type& graph) {
std::pair<typename type::edge_descriptor, bool> edge_exists =
std::make_pair(std::make_pair(source_vertex, destination_vertex), false);
for (std::size_t dimension_index = 0;
dimension_index < Dimensions;
++dimension_index) {
typename type::vertices_size_type dim_difference = 0;
typename type::vertices_size_type
source_dim = source_vertex[dimension_index],
dest_dim = destination_vertex[dimension_index];
dim_difference = (source_dim > dest_dim) ?
(source_dim - dest_dim) : (dest_dim - source_dim);
if (dim_difference > 0) {
// If we've already found a valid edge, this would mean that
// the vertices are really diagonal across dimensions and
// therefore not connected.
if (edge_exists.second) {
edge_exists.second = false;
break;
}
// If the difference is one, the vertices are right next to
// each other and the edge is valid. The edge is still
// valid, though, if the dimension wraps and the vertices
// are on opposite ends.
if ((dim_difference == 1) ||
(graph.wrapped(dimension_index) &&
(((source_dim == 0) && (dest_dim == (graph.length(dimension_index) - 1))) ||
((dest_dim == 0) && (source_dim == (graph.length(dimension_index) - 1)))))) {
edge_exists.second = true;
// Stay in the loop to check for diagonal vertices.
}
else {
// Stop checking - the vertices are too far apart.
edge_exists.second = false;
break;
}
}
} // for dimension_index
return (edge_exists);
}
//=============================
// Index Property Map Functions
//=============================
friend inline typename type::vertices_size_type
get(vertex_index_t,
const type& graph,
typename type::vertex_descriptor vertex) {
return (graph.index_of(vertex));
}
friend inline typename type::edges_size_type
get(edge_index_t,
const type& graph,
typename type::edge_descriptor edge) {
return (graph.index_of(edge));
}
friend inline grid_graph_index_map<
type,
typename type::vertex_descriptor,
typename type::vertices_size_type>
get(vertex_index_t, const type& graph) {
return (grid_graph_index_map<
type,
typename type::vertex_descriptor,
typename type::vertices_size_type>(graph));
}
friend inline grid_graph_index_map<
type,
typename type::edge_descriptor,
typename type::edges_size_type>
get(edge_index_t, const type& graph) {
return (grid_graph_index_map<
type,
typename type::edge_descriptor,
typename type::edges_size_type>(graph));
}
friend inline grid_graph_reverse_edge_map<
typename type::edge_descriptor>
get(edge_reverse_t, const type& graph) {
return (grid_graph_reverse_edge_map<
typename type::edge_descriptor>());
}
template<typename Graph,
typename Descriptor,
typename Index>
friend struct grid_graph_index_map;
template<typename Descriptor>
friend struct grid_graph_reverse_edge_map;
}; // grid_graph
} // namespace boost
#undef BOOST_GRID_GRAPH_TYPE
#undef BOOST_GRID_GRAPH_TEMPLATE_PARAMS
#undef BOOST_GRID_GRAPH_TRAITS_T
#endif // BOOST_GRAPH_GRID_GRAPH_HPP