// Copyright 2009 The Trustees of Indiana University. | |
// 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) | |
// Authors: Jeremiah Willcock | |
// Douglas Gregor | |
// Andrew Lumsdaine | |
#ifndef BOOST_GRAPH_TOPOLOGY_HPP | |
#define BOOST_GRAPH_TOPOLOGY_HPP | |
#include <boost/config/no_tr1/cmath.hpp> | |
#include <cmath> | |
#include <boost/random/uniform_01.hpp> | |
#include <boost/random/linear_congruential.hpp> | |
#include <boost/math/constants/constants.hpp> // For root_two | |
#include <boost/algorithm/minmax.hpp> | |
#include <boost/config.hpp> // For BOOST_STATIC_CONSTANT | |
#include <boost/math/special_functions/hypot.hpp> | |
// Classes and concepts to represent points in a space, with distance and move | |
// operations (used for Gurson-Atun layout), plus other things like bounding | |
// boxes used for other layout algorithms. | |
namespace boost { | |
/*********************************************************** | |
* Topologies * | |
***********************************************************/ | |
template<std::size_t Dims> | |
class convex_topology | |
{ | |
public: // For VisualAge C++ | |
struct point | |
{ | |
BOOST_STATIC_CONSTANT(std::size_t, dimensions = Dims); | |
point() { } | |
double& operator[](std::size_t i) {return values[i];} | |
const double& operator[](std::size_t i) const {return values[i];} | |
private: | |
double values[Dims]; | |
}; | |
public: // For VisualAge C++ | |
struct point_difference | |
{ | |
BOOST_STATIC_CONSTANT(std::size_t, dimensions = Dims); | |
point_difference() { | |
for (std::size_t i = 0; i < Dims; ++i) values[i] = 0.; | |
} | |
double& operator[](std::size_t i) {return values[i];} | |
const double& operator[](std::size_t i) const {return values[i];} | |
friend point_difference operator+(const point_difference& a, const point_difference& b) { | |
point_difference result; | |
for (std::size_t i = 0; i < Dims; ++i) | |
result[i] = a[i] + b[i]; | |
return result; | |
} | |
friend point_difference& operator+=(point_difference& a, const point_difference& b) { | |
for (std::size_t i = 0; i < Dims; ++i) | |
a[i] += b[i]; | |
return a; | |
} | |
friend point_difference operator-(const point_difference& a) { | |
point_difference result; | |
for (std::size_t i = 0; i < Dims; ++i) | |
result[i] = -a[i]; | |
return result; | |
} | |
friend point_difference operator-(const point_difference& a, const point_difference& b) { | |
point_difference result; | |
for (std::size_t i = 0; i < Dims; ++i) | |
result[i] = a[i] - b[i]; | |
return result; | |
} | |
friend point_difference& operator-=(point_difference& a, const point_difference& b) { | |
for (std::size_t i = 0; i < Dims; ++i) | |
a[i] -= b[i]; | |
return a; | |
} | |
friend point_difference operator*(const point_difference& a, const point_difference& b) { | |
point_difference result; | |
for (std::size_t i = 0; i < Dims; ++i) | |
result[i] = a[i] * b[i]; | |
return result; | |
} | |
friend point_difference operator*(const point_difference& a, double b) { | |
point_difference result; | |
for (std::size_t i = 0; i < Dims; ++i) | |
result[i] = a[i] * b; | |
return result; | |
} | |
friend point_difference operator*(double a, const point_difference& b) { | |
point_difference result; | |
for (std::size_t i = 0; i < Dims; ++i) | |
result[i] = a * b[i]; | |
return result; | |
} | |
friend point_difference operator/(const point_difference& a, const point_difference& b) { | |
point_difference result; | |
for (std::size_t i = 0; i < Dims; ++i) | |
result[i] = (b[i] == 0.) ? 0. : a[i] / b[i]; | |
return result; | |
} | |
friend double dot(const point_difference& a, const point_difference& b) { | |
double result = 0; | |
for (std::size_t i = 0; i < Dims; ++i) | |
result += a[i] * b[i]; | |
return result; | |
} | |
private: | |
double values[Dims]; | |
}; | |
public: | |
typedef point point_type; | |
typedef point_difference point_difference_type; | |
double distance(point a, point b) const | |
{ | |
double dist = 0.; | |
for (std::size_t i = 0; i < Dims; ++i) { | |
double diff = b[i] - a[i]; | |
dist = boost::math::hypot(dist, diff); | |
} | |
// Exact properties of the distance are not important, as long as | |
// < on what this returns matches real distances; l_2 is used because | |
// Fruchterman-Reingold also uses this code and it relies on l_2. | |
return dist; | |
} | |
point move_position_toward(point a, double fraction, point b) const | |
{ | |
point result; | |
for (std::size_t i = 0; i < Dims; ++i) | |
result[i] = a[i] + (b[i] - a[i]) * fraction; | |
return result; | |
} | |
point_difference difference(point a, point b) const { | |
point_difference result; | |
for (std::size_t i = 0; i < Dims; ++i) | |
result[i] = a[i] - b[i]; | |
return result; | |
} | |
point adjust(point a, point_difference delta) const { | |
point result; | |
for (std::size_t i = 0; i < Dims; ++i) | |
result[i] = a[i] + delta[i]; | |
return result; | |
} | |
point pointwise_min(point a, point b) const { | |
BOOST_USING_STD_MIN(); | |
point result; | |
for (std::size_t i = 0; i < Dims; ++i) | |
result[i] = min BOOST_PREVENT_MACRO_SUBSTITUTION (a[i], b[i]); | |
return result; | |
} | |
point pointwise_max(point a, point b) const { | |
BOOST_USING_STD_MAX(); | |
point result; | |
for (std::size_t i = 0; i < Dims; ++i) | |
result[i] = max BOOST_PREVENT_MACRO_SUBSTITUTION (a[i], b[i]); | |
return result; | |
} | |
double norm(point_difference delta) const { | |
double n = 0.; | |
for (std::size_t i = 0; i < Dims; ++i) | |
n = boost::math::hypot(n, delta[i]); | |
return n; | |
} | |
double volume(point_difference delta) const { | |
double n = 1.; | |
for (std::size_t i = 0; i < Dims; ++i) | |
n *= delta[i]; | |
return n; | |
} | |
}; | |
template<std::size_t Dims, | |
typename RandomNumberGenerator = minstd_rand> | |
class hypercube_topology : public convex_topology<Dims> | |
{ | |
typedef uniform_01<RandomNumberGenerator, double> rand_t; | |
public: | |
typedef typename convex_topology<Dims>::point_type point_type; | |
typedef typename convex_topology<Dims>::point_difference_type point_difference_type; | |
explicit hypercube_topology(double scaling = 1.0) | |
: gen_ptr(new RandomNumberGenerator), rand(new rand_t(*gen_ptr)), | |
scaling(scaling) | |
{ } | |
hypercube_topology(RandomNumberGenerator& gen, double scaling = 1.0) | |
: gen_ptr(), rand(new rand_t(gen)), scaling(scaling) { } | |
point_type random_point() const | |
{ | |
point_type p; | |
for (std::size_t i = 0; i < Dims; ++i) | |
p[i] = (*rand)() * scaling; | |
return p; | |
} | |
point_type bound(point_type a) const | |
{ | |
BOOST_USING_STD_MIN(); | |
BOOST_USING_STD_MAX(); | |
point_type p; | |
for (std::size_t i = 0; i < Dims; ++i) | |
p[i] = min BOOST_PREVENT_MACRO_SUBSTITUTION (scaling, max BOOST_PREVENT_MACRO_SUBSTITUTION (-scaling, a[i])); | |
return p; | |
} | |
double distance_from_boundary(point_type a) const | |
{ | |
BOOST_USING_STD_MIN(); | |
BOOST_USING_STD_MAX(); | |
#ifndef BOOST_NO_STDC_NAMESPACE | |
using std::abs; | |
#endif | |
BOOST_STATIC_ASSERT (Dims >= 1); | |
double dist = abs(scaling - a[0]); | |
for (std::size_t i = 1; i < Dims; ++i) | |
dist = min BOOST_PREVENT_MACRO_SUBSTITUTION (dist, abs(scaling - a[i])); | |
return dist; | |
} | |
point_type center() const { | |
point_type result; | |
for (std::size_t i = 0; i < Dims; ++i) | |
result[i] = scaling * .5; | |
return result; | |
} | |
point_type origin() const { | |
point_type result; | |
for (std::size_t i = 0; i < Dims; ++i) | |
result[i] = 0; | |
return result; | |
} | |
point_difference_type extent() const { | |
point_difference_type result; | |
for (std::size_t i = 0; i < Dims; ++i) | |
result[i] = scaling; | |
return result; | |
} | |
private: | |
shared_ptr<RandomNumberGenerator> gen_ptr; | |
shared_ptr<rand_t> rand; | |
double scaling; | |
}; | |
template<typename RandomNumberGenerator = minstd_rand> | |
class square_topology : public hypercube_topology<2, RandomNumberGenerator> | |
{ | |
typedef hypercube_topology<2, RandomNumberGenerator> inherited; | |
public: | |
explicit square_topology(double scaling = 1.0) : inherited(scaling) { } | |
square_topology(RandomNumberGenerator& gen, double scaling = 1.0) | |
: inherited(gen, scaling) { } | |
}; | |
template<typename RandomNumberGenerator = minstd_rand> | |
class rectangle_topology : public convex_topology<2> | |
{ | |
typedef uniform_01<RandomNumberGenerator, double> rand_t; | |
public: | |
rectangle_topology(double left, double top, double right, double bottom) | |
: gen_ptr(new RandomNumberGenerator), rand(new rand_t(*gen_ptr)), | |
left(std::min BOOST_PREVENT_MACRO_SUBSTITUTION (left, right)), | |
top(std::min BOOST_PREVENT_MACRO_SUBSTITUTION (top, bottom)), | |
right(std::max BOOST_PREVENT_MACRO_SUBSTITUTION (left, right)), | |
bottom(std::max BOOST_PREVENT_MACRO_SUBSTITUTION (top, bottom)) { } | |
rectangle_topology(RandomNumberGenerator& gen, double left, double top, double right, double bottom) | |
: gen_ptr(), rand(new rand_t(gen)), | |
left(std::min BOOST_PREVENT_MACRO_SUBSTITUTION (left, right)), | |
top(std::min BOOST_PREVENT_MACRO_SUBSTITUTION (top, bottom)), | |
right(std::max BOOST_PREVENT_MACRO_SUBSTITUTION (left, right)), | |
bottom(std::max BOOST_PREVENT_MACRO_SUBSTITUTION (top, bottom)) { } | |
typedef typename convex_topology<2>::point_type point_type; | |
typedef typename convex_topology<2>::point_difference_type point_difference_type; | |
point_type random_point() const | |
{ | |
point_type p; | |
p[0] = (*rand)() * (right - left) + left; | |
p[1] = (*rand)() * (bottom - top) + top; | |
return p; | |
} | |
point_type bound(point_type a) const | |
{ | |
BOOST_USING_STD_MIN(); | |
BOOST_USING_STD_MAX(); | |
point_type p; | |
p[0] = min BOOST_PREVENT_MACRO_SUBSTITUTION (right, max BOOST_PREVENT_MACRO_SUBSTITUTION (left, a[0])); | |
p[1] = min BOOST_PREVENT_MACRO_SUBSTITUTION (bottom, max BOOST_PREVENT_MACRO_SUBSTITUTION (top, a[1])); | |
return p; | |
} | |
double distance_from_boundary(point_type a) const | |
{ | |
BOOST_USING_STD_MIN(); | |
BOOST_USING_STD_MAX(); | |
#ifndef BOOST_NO_STDC_NAMESPACE | |
using std::abs; | |
#endif | |
double dist = abs(left - a[0]); | |
dist = min BOOST_PREVENT_MACRO_SUBSTITUTION (dist, abs(right - a[0])); | |
dist = min BOOST_PREVENT_MACRO_SUBSTITUTION (dist, abs(top - a[1])); | |
dist = min BOOST_PREVENT_MACRO_SUBSTITUTION (dist, abs(bottom - a[1])); | |
return dist; | |
} | |
point_type center() const { | |
point_type result; | |
result[0] = (left + right) / 2.; | |
result[1] = (top + bottom) / 2.; | |
return result; | |
} | |
point_type origin() const { | |
point_type result; | |
result[0] = left; | |
result[1] = top; | |
return result; | |
} | |
point_difference_type extent() const { | |
point_difference_type result; | |
result[0] = right - left; | |
result[1] = bottom - top; | |
return result; | |
} | |
private: | |
shared_ptr<RandomNumberGenerator> gen_ptr; | |
shared_ptr<rand_t> rand; | |
double left, top, right, bottom; | |
}; | |
template<typename RandomNumberGenerator = minstd_rand> | |
class cube_topology : public hypercube_topology<3, RandomNumberGenerator> | |
{ | |
typedef hypercube_topology<3, RandomNumberGenerator> inherited; | |
public: | |
explicit cube_topology(double scaling = 1.0) : inherited(scaling) { } | |
cube_topology(RandomNumberGenerator& gen, double scaling = 1.0) | |
: inherited(gen, scaling) { } | |
}; | |
template<std::size_t Dims, | |
typename RandomNumberGenerator = minstd_rand> | |
class ball_topology : public convex_topology<Dims> | |
{ | |
typedef uniform_01<RandomNumberGenerator, double> rand_t; | |
public: | |
typedef typename convex_topology<Dims>::point_type point_type; | |
typedef typename convex_topology<Dims>::point_difference_type point_difference_type; | |
explicit ball_topology(double radius = 1.0) | |
: gen_ptr(new RandomNumberGenerator), rand(new rand_t(*gen_ptr)), | |
radius(radius) | |
{ } | |
ball_topology(RandomNumberGenerator& gen, double radius = 1.0) | |
: gen_ptr(), rand(new rand_t(gen)), radius(radius) { } | |
point_type random_point() const | |
{ | |
point_type p; | |
double dist_sum; | |
do { | |
dist_sum = 0.0; | |
for (std::size_t i = 0; i < Dims; ++i) { | |
double x = (*rand)() * 2*radius - radius; | |
p[i] = x; | |
dist_sum += x * x; | |
} | |
} while (dist_sum > radius*radius); | |
return p; | |
} | |
point_type bound(point_type a) const | |
{ | |
BOOST_USING_STD_MIN(); | |
BOOST_USING_STD_MAX(); | |
double r = 0.; | |
for (std::size_t i = 0; i < Dims; ++i) | |
r = boost::math::hypot(r, a[i]); | |
if (r <= radius) return a; | |
double scaling_factor = radius / r; | |
point_type p; | |
for (std::size_t i = 0; i < Dims; ++i) | |
p[i] = a[i] * scaling_factor; | |
return p; | |
} | |
double distance_from_boundary(point_type a) const | |
{ | |
double r = 0.; | |
for (std::size_t i = 0; i < Dims; ++i) | |
r = boost::math::hypot(r, a[i]); | |
return radius - r; | |
} | |
point_type center() const { | |
point_type result; | |
for (std::size_t i = 0; i < Dims; ++i) | |
result[i] = 0; | |
return result; | |
} | |
point_type origin() const { | |
point_type result; | |
for (std::size_t i = 0; i < Dims; ++i) | |
result[i] = -radius; | |
return result; | |
} | |
point_difference_type extent() const { | |
point_difference_type result; | |
for (std::size_t i = 0; i < Dims; ++i) | |
result[i] = 2. * radius; | |
return result; | |
} | |
private: | |
shared_ptr<RandomNumberGenerator> gen_ptr; | |
shared_ptr<rand_t> rand; | |
double radius; | |
}; | |
template<typename RandomNumberGenerator = minstd_rand> | |
class circle_topology : public ball_topology<2, RandomNumberGenerator> | |
{ | |
typedef ball_topology<2, RandomNumberGenerator> inherited; | |
public: | |
explicit circle_topology(double radius = 1.0) : inherited(radius) { } | |
circle_topology(RandomNumberGenerator& gen, double radius = 1.0) | |
: inherited(gen, radius) { } | |
}; | |
template<typename RandomNumberGenerator = minstd_rand> | |
class sphere_topology : public ball_topology<3, RandomNumberGenerator> | |
{ | |
typedef ball_topology<3, RandomNumberGenerator> inherited; | |
public: | |
explicit sphere_topology(double radius = 1.0) : inherited(radius) { } | |
sphere_topology(RandomNumberGenerator& gen, double radius = 1.0) | |
: inherited(gen, radius) { } | |
}; | |
template<typename RandomNumberGenerator = minstd_rand> | |
class heart_topology | |
{ | |
// Heart is defined as the union of three shapes: | |
// Square w/ corners (+-1000, -1000), (0, 0), (0, -2000) | |
// Circle centered at (-500, -500) radius 500*sqrt(2) | |
// Circle centered at (500, -500) radius 500*sqrt(2) | |
// Bounding box (-1000, -2000) - (1000, 500*(sqrt(2) - 1)) | |
struct point | |
{ | |
point() { values[0] = 0.0; values[1] = 0.0; } | |
point(double x, double y) { values[0] = x; values[1] = y; } | |
double& operator[](std::size_t i) { return values[i]; } | |
double operator[](std::size_t i) const { return values[i]; } | |
private: | |
double values[2]; | |
}; | |
bool in_heart(point p) const | |
{ | |
#ifndef BOOST_NO_STDC_NAMESPACE | |
using std::abs; | |
#endif | |
if (p[1] < abs(p[0]) - 2000) return false; // Bottom | |
if (p[1] <= -1000) return true; // Diagonal of square | |
if (boost::math::hypot(p[0] - -500, p[1] - -500) <= 500. * boost::math::constants::root_two<double>()) | |
return true; // Left circle | |
if (boost::math::hypot(p[0] - 500, p[1] - -500) <= 500. * boost::math::constants::root_two<double>()) | |
return true; // Right circle | |
return false; | |
} | |
bool segment_within_heart(point p1, point p2) const | |
{ | |
// Assumes that p1 and p2 are within the heart | |
if ((p1[0] < 0) == (p2[0] < 0)) return true; // Same side of symmetry line | |
if (p1[0] == p2[0]) return true; // Vertical | |
double slope = (p2[1] - p1[1]) / (p2[0] - p1[0]); | |
double intercept = p1[1] - p1[0] * slope; | |
if (intercept > 0) return false; // Crosses between circles | |
return true; | |
} | |
typedef uniform_01<RandomNumberGenerator, double> rand_t; | |
public: | |
typedef point point_type; | |
heart_topology() | |
: gen_ptr(new RandomNumberGenerator), rand(new rand_t(*gen_ptr)) { } | |
heart_topology(RandomNumberGenerator& gen) | |
: gen_ptr(), rand(new rand_t(gen)) { } | |
point random_point() const | |
{ | |
point result; | |
do { | |
result[0] = (*rand)() * (1000 + 1000 * boost::math::constants::root_two<double>()) - (500 + 500 * boost::math::constants::root_two<double>()); | |
result[1] = (*rand)() * (2000 + 500 * (boost::math::constants::root_two<double>() - 1)) - 2000; | |
} while (!in_heart(result)); | |
return result; | |
} | |
// Not going to provide clipping to bounding region or distance from boundary | |
double distance(point a, point b) const | |
{ | |
if (segment_within_heart(a, b)) { | |
// Straight line | |
return boost::math::hypot(b[0] - a[0], b[1] - a[1]); | |
} else { | |
// Straight line bending around (0, 0) | |
return boost::math::hypot(a[0], a[1]) + boost::math::hypot(b[0], b[1]); | |
} | |
} | |
point move_position_toward(point a, double fraction, point b) const | |
{ | |
if (segment_within_heart(a, b)) { | |
// Straight line | |
return point(a[0] + (b[0] - a[0]) * fraction, | |
a[1] + (b[1] - a[1]) * fraction); | |
} else { | |
double distance_to_point_a = boost::math::hypot(a[0], a[1]); | |
double distance_to_point_b = boost::math::hypot(b[0], b[1]); | |
double location_of_point = distance_to_point_a / | |
(distance_to_point_a + distance_to_point_b); | |
if (fraction < location_of_point) | |
return point(a[0] * (1 - fraction / location_of_point), | |
a[1] * (1 - fraction / location_of_point)); | |
else | |
return point( | |
b[0] * ((fraction - location_of_point) / (1 - location_of_point)), | |
b[1] * ((fraction - location_of_point) / (1 - location_of_point))); | |
} | |
} | |
private: | |
shared_ptr<RandomNumberGenerator> gen_ptr; | |
shared_ptr<rand_t> rand; | |
}; | |
} // namespace boost | |
#endif // BOOST_GRAPH_TOPOLOGY_HPP |