632 lines
22 KiB
C++
Executable File
632 lines
22 KiB
C++
Executable File
// Copyright 2004 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_GURSOY_ATUN_LAYOUT_HPP
|
|
#define BOOST_GRAPH_GURSOY_ATUN_LAYOUT_HPP
|
|
|
|
// Gursoy-Atun graph layout, based on:
|
|
// "Neighbourhood Preserving Load Balancing: A Self-Organizing Approach"
|
|
// in EuroPar 2000, p. 234 of LNCS 1900
|
|
// http://springerlink.metapress.com/link.asp?id=pcu07ew5rhexp9yt
|
|
|
|
#include <cmath>
|
|
#include <vector>
|
|
#include <exception>
|
|
#include <algorithm>
|
|
|
|
#include <boost/graph/visitors.hpp>
|
|
#include <boost/graph/properties.hpp>
|
|
#include <boost/random/uniform_01.hpp>
|
|
#include <boost/random/linear_congruential.hpp>
|
|
#include <boost/shared_ptr.hpp>
|
|
#include <boost/graph/breadth_first_search.hpp>
|
|
#include <boost/graph/dijkstra_shortest_paths.hpp>
|
|
#include <boost/graph/named_function_params.hpp>
|
|
|
|
namespace boost {
|
|
|
|
namespace detail {
|
|
|
|
struct over_distance_limit : public std::exception {};
|
|
|
|
template <typename PositionMap, typename NodeDistanceMap, typename Topology,
|
|
typename Graph>
|
|
struct update_position_visitor {
|
|
typedef typename Topology::point_type Point;
|
|
PositionMap position_map;
|
|
NodeDistanceMap node_distance;
|
|
const Topology& space;
|
|
Point input_vector;
|
|
double distance_limit;
|
|
double learning_constant;
|
|
double falloff_ratio;
|
|
|
|
typedef boost::on_examine_vertex event_filter;
|
|
|
|
typedef typename graph_traits<Graph>::vertex_descriptor
|
|
vertex_descriptor;
|
|
|
|
update_position_visitor(PositionMap position_map,
|
|
NodeDistanceMap node_distance,
|
|
const Topology& space,
|
|
const Point& input_vector,
|
|
double distance_limit,
|
|
double learning_constant,
|
|
double falloff_ratio):
|
|
position_map(position_map), node_distance(node_distance),
|
|
space(space),
|
|
input_vector(input_vector), distance_limit(distance_limit),
|
|
learning_constant(learning_constant), falloff_ratio(falloff_ratio) {}
|
|
|
|
void operator()(vertex_descriptor v, const Graph&) const
|
|
{
|
|
#ifndef BOOST_NO_STDC_NAMESPACE
|
|
using std::pow;
|
|
#endif
|
|
|
|
if (get(node_distance, v) > distance_limit)
|
|
throw over_distance_limit();
|
|
Point old_position = get(position_map, v);
|
|
double distance = get(node_distance, v);
|
|
double fraction =
|
|
learning_constant * pow(falloff_ratio, distance * distance);
|
|
put(position_map, v,
|
|
space.move_position_toward(old_position, fraction, input_vector));
|
|
}
|
|
};
|
|
|
|
template<typename EdgeWeightMap>
|
|
struct gursoy_shortest
|
|
{
|
|
template<typename Graph, typename NodeDistanceMap, typename UpdatePosition>
|
|
static inline void
|
|
run(const Graph& g, typename graph_traits<Graph>::vertex_descriptor s,
|
|
NodeDistanceMap node_distance, UpdatePosition& update_position,
|
|
EdgeWeightMap weight)
|
|
{
|
|
boost::dijkstra_shortest_paths(g, s, weight_map(weight).
|
|
visitor(boost::make_dijkstra_visitor(std::make_pair(
|
|
boost::record_distances(node_distance, boost::on_edge_relaxed()),
|
|
update_position))));
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct gursoy_shortest<dummy_property_map>
|
|
{
|
|
template<typename Graph, typename NodeDistanceMap, typename UpdatePosition>
|
|
static inline void
|
|
run(const Graph& g, typename graph_traits<Graph>::vertex_descriptor s,
|
|
NodeDistanceMap node_distance, UpdatePosition& update_position,
|
|
dummy_property_map)
|
|
{
|
|
boost::breadth_first_search(g, s,
|
|
visitor(boost::make_bfs_visitor(std::make_pair(
|
|
boost::record_distances(node_distance, boost::on_tree_edge()),
|
|
update_position))));
|
|
}
|
|
};
|
|
|
|
} // namespace detail
|
|
|
|
template <typename VertexListAndIncidenceGraph, typename Topology,
|
|
typename PositionMap, typename Diameter, typename VertexIndexMap,
|
|
typename EdgeWeightMap>
|
|
void
|
|
gursoy_atun_step
|
|
(const VertexListAndIncidenceGraph& graph,
|
|
const Topology& space,
|
|
PositionMap position,
|
|
Diameter diameter,
|
|
double learning_constant,
|
|
VertexIndexMap vertex_index_map,
|
|
EdgeWeightMap weight)
|
|
{
|
|
#ifndef BOOST_NO_STDC_NAMESPACE
|
|
using std::pow;
|
|
using std::exp;
|
|
#endif
|
|
|
|
typedef typename graph_traits<VertexListAndIncidenceGraph>::vertex_iterator
|
|
vertex_iterator;
|
|
typedef typename graph_traits<VertexListAndIncidenceGraph>::vertex_descriptor
|
|
vertex_descriptor;
|
|
typedef typename Topology::point_type point_type;
|
|
vertex_iterator i, iend;
|
|
std::vector<double> distance_from_input_vector(num_vertices(graph));
|
|
typedef boost::iterator_property_map<std::vector<double>::iterator,
|
|
VertexIndexMap,
|
|
double, double&>
|
|
DistanceFromInputMap;
|
|
DistanceFromInputMap distance_from_input(distance_from_input_vector.begin(),
|
|
vertex_index_map);
|
|
std::vector<double> node_distance_map_vector(num_vertices(graph));
|
|
typedef boost::iterator_property_map<std::vector<double>::iterator,
|
|
VertexIndexMap,
|
|
double, double&>
|
|
NodeDistanceMap;
|
|
NodeDistanceMap node_distance(node_distance_map_vector.begin(),
|
|
vertex_index_map);
|
|
point_type input_vector = space.random_point();
|
|
vertex_descriptor min_distance_loc
|
|
= graph_traits<VertexListAndIncidenceGraph>::null_vertex();
|
|
double min_distance = 0.0;
|
|
bool min_distance_unset = true;
|
|
for (boost::tie(i, iend) = vertices(graph); i != iend; ++i) {
|
|
double this_distance = space.distance(get(position, *i), input_vector);
|
|
put(distance_from_input, *i, this_distance);
|
|
if (min_distance_unset || this_distance < min_distance) {
|
|
min_distance = this_distance;
|
|
min_distance_loc = *i;
|
|
}
|
|
min_distance_unset = false;
|
|
}
|
|
assert (!min_distance_unset); // Graph must have at least one vertex
|
|
boost::detail::update_position_visitor<
|
|
PositionMap, NodeDistanceMap, Topology,
|
|
VertexListAndIncidenceGraph>
|
|
update_position(position, node_distance, space,
|
|
input_vector, diameter, learning_constant,
|
|
exp(-1. / (2 * diameter * diameter)));
|
|
std::fill(node_distance_map_vector.begin(), node_distance_map_vector.end(), 0);
|
|
try {
|
|
typedef detail::gursoy_shortest<EdgeWeightMap> shortest;
|
|
shortest::run(graph, min_distance_loc, node_distance, update_position,
|
|
weight);
|
|
} catch (detail::over_distance_limit) {
|
|
/* Thrown to break out of BFS or Dijkstra early */
|
|
}
|
|
}
|
|
|
|
template <typename VertexListAndIncidenceGraph, typename Topology,
|
|
typename PositionMap, typename VertexIndexMap,
|
|
typename EdgeWeightMap>
|
|
void gursoy_atun_refine(const VertexListAndIncidenceGraph& graph,
|
|
const Topology& space,
|
|
PositionMap position,
|
|
int nsteps,
|
|
double diameter_initial,
|
|
double diameter_final,
|
|
double learning_constant_initial,
|
|
double learning_constant_final,
|
|
VertexIndexMap vertex_index_map,
|
|
EdgeWeightMap weight)
|
|
{
|
|
#ifndef BOOST_NO_STDC_NAMESPACE
|
|
using std::pow;
|
|
using std::exp;
|
|
#endif
|
|
|
|
typedef typename graph_traits<VertexListAndIncidenceGraph>::vertex_iterator
|
|
vertex_iterator;
|
|
typedef typename graph_traits<VertexListAndIncidenceGraph>::vertex_descriptor
|
|
vertex_descriptor;
|
|
typedef typename Topology::point_type point_type;
|
|
vertex_iterator i, iend;
|
|
double diameter_ratio = (double)diameter_final / diameter_initial;
|
|
double learning_constant_ratio =
|
|
learning_constant_final / learning_constant_initial;
|
|
std::vector<double> distance_from_input_vector(num_vertices(graph));
|
|
typedef boost::iterator_property_map<std::vector<double>::iterator,
|
|
VertexIndexMap,
|
|
double, double&>
|
|
DistanceFromInputMap;
|
|
DistanceFromInputMap distance_from_input(distance_from_input_vector.begin(),
|
|
vertex_index_map);
|
|
std::vector<int> node_distance_map_vector(num_vertices(graph));
|
|
typedef boost::iterator_property_map<std::vector<int>::iterator,
|
|
VertexIndexMap, double, double&>
|
|
NodeDistanceMap;
|
|
NodeDistanceMap node_distance(node_distance_map_vector.begin(),
|
|
vertex_index_map);
|
|
for (int round = 0; round < nsteps; ++round) {
|
|
double part_done = (double)round / (nsteps - 1);
|
|
int diameter = (int)(diameter_initial * pow(diameter_ratio, part_done));
|
|
double learning_constant =
|
|
learning_constant_initial * pow(learning_constant_ratio, part_done);
|
|
gursoy_atun_step(graph, space, position, diameter, learning_constant,
|
|
vertex_index_map, weight);
|
|
}
|
|
}
|
|
|
|
template <typename VertexListAndIncidenceGraph, typename Topology,
|
|
typename PositionMap, typename VertexIndexMap,
|
|
typename EdgeWeightMap>
|
|
void gursoy_atun_layout(const VertexListAndIncidenceGraph& graph,
|
|
const Topology& space,
|
|
PositionMap position,
|
|
int nsteps,
|
|
double diameter_initial,
|
|
double diameter_final,
|
|
double learning_constant_initial,
|
|
double learning_constant_final,
|
|
VertexIndexMap vertex_index_map,
|
|
EdgeWeightMap weight)
|
|
{
|
|
typedef typename graph_traits<VertexListAndIncidenceGraph>::vertex_iterator
|
|
vertex_iterator;
|
|
vertex_iterator i, iend;
|
|
for (boost::tie(i, iend) = vertices(graph); i != iend; ++i) {
|
|
put(position, *i, space.random_point());
|
|
}
|
|
gursoy_atun_refine(graph, space,
|
|
position, nsteps,
|
|
diameter_initial, diameter_final,
|
|
learning_constant_initial, learning_constant_final,
|
|
vertex_index_map, weight);
|
|
}
|
|
|
|
template <typename VertexListAndIncidenceGraph, typename Topology,
|
|
typename PositionMap, typename VertexIndexMap>
|
|
void gursoy_atun_layout(const VertexListAndIncidenceGraph& graph,
|
|
const Topology& space,
|
|
PositionMap position,
|
|
int nsteps,
|
|
double diameter_initial,
|
|
double diameter_final,
|
|
double learning_constant_initial,
|
|
double learning_constant_final,
|
|
VertexIndexMap vertex_index_map)
|
|
{
|
|
gursoy_atun_layout(graph, space, position, nsteps,
|
|
diameter_initial, diameter_final,
|
|
learning_constant_initial, learning_constant_final,
|
|
vertex_index_map, dummy_property_map());
|
|
}
|
|
|
|
template <typename VertexListAndIncidenceGraph, typename Topology,
|
|
typename PositionMap>
|
|
void gursoy_atun_layout(const VertexListAndIncidenceGraph& graph,
|
|
const Topology& space,
|
|
PositionMap position,
|
|
int nsteps,
|
|
double diameter_initial,
|
|
double diameter_final = 1.0,
|
|
double learning_constant_initial = 0.8,
|
|
double learning_constant_final = 0.2)
|
|
{
|
|
gursoy_atun_layout(graph, space, position, nsteps, diameter_initial,
|
|
diameter_final, learning_constant_initial,
|
|
learning_constant_final, get(vertex_index, graph));
|
|
}
|
|
|
|
template <typename VertexListAndIncidenceGraph, typename Topology,
|
|
typename PositionMap>
|
|
void gursoy_atun_layout(const VertexListAndIncidenceGraph& graph,
|
|
const Topology& space,
|
|
PositionMap position,
|
|
int nsteps)
|
|
{
|
|
#ifndef BOOST_NO_STDC_NAMESPACE
|
|
using std::sqrt;
|
|
#endif
|
|
|
|
gursoy_atun_layout(graph, space, position, nsteps,
|
|
sqrt((double)num_vertices(graph)));
|
|
}
|
|
|
|
template <typename VertexListAndIncidenceGraph, typename Topology,
|
|
typename PositionMap>
|
|
void gursoy_atun_layout(const VertexListAndIncidenceGraph& graph,
|
|
const Topology& space,
|
|
PositionMap position)
|
|
{
|
|
gursoy_atun_layout(graph, space, position, num_vertices(graph));
|
|
}
|
|
|
|
template<typename VertexListAndIncidenceGraph, typename Topology,
|
|
typename PositionMap, typename P, typename T, typename R>
|
|
void
|
|
gursoy_atun_layout(const VertexListAndIncidenceGraph& graph,
|
|
const Topology& space,
|
|
PositionMap position,
|
|
const bgl_named_params<P,T,R>& params)
|
|
{
|
|
#ifndef BOOST_NO_STDC_NAMESPACE
|
|
using std::sqrt;
|
|
#endif
|
|
|
|
std::pair<double, double> diam(sqrt(double(num_vertices(graph))), 1.0);
|
|
std::pair<double, double> learn(0.8, 0.2);
|
|
gursoy_atun_layout(graph, space, position,
|
|
choose_param(get_param(params, iterations_t()),
|
|
num_vertices(graph)),
|
|
choose_param(get_param(params, diameter_range_t()),
|
|
diam).first,
|
|
choose_param(get_param(params, diameter_range_t()),
|
|
diam).second,
|
|
choose_param(get_param(params, learning_constant_range_t()),
|
|
learn).first,
|
|
choose_param(get_param(params, learning_constant_range_t()),
|
|
learn).second,
|
|
choose_const_pmap(get_param(params, vertex_index), graph,
|
|
vertex_index),
|
|
choose_param(get_param(params, edge_weight),
|
|
dummy_property_map()));
|
|
}
|
|
|
|
/***********************************************************
|
|
* Topologies *
|
|
***********************************************************/
|
|
template<std::size_t Dims>
|
|
class convex_topology
|
|
{
|
|
struct point
|
|
{
|
|
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:
|
|
typedef point point_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 += diff * diff;
|
|
}
|
|
// Exact properties of the distance are not important, as long as
|
|
// < on what this returns matches real distances
|
|
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;
|
|
}
|
|
};
|
|
|
|
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;
|
|
|
|
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;
|
|
}
|
|
|
|
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 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;
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
using std::pow;
|
|
#endif
|
|
|
|
if (p[1] < abs(p[0]) - 2000) return false; // Bottom
|
|
if (p[1] <= -1000) return true; // Diagonal of square
|
|
if (pow(p[0] - -500, 2) + pow(p[1] - -500, 2) <= 500000)
|
|
return true; // Left circle
|
|
if (pow(p[0] - 500, 2) + pow(p[1] - -500, 2) <= 500000)
|
|
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
|
|
{
|
|
#ifndef BOOST_NO_STDC_NAMESPACE
|
|
using std::sqrt;
|
|
#endif
|
|
|
|
point result;
|
|
double sqrt2 = sqrt(2.);
|
|
do {
|
|
result[0] = (*rand)() * (1000 + 1000 * sqrt2) - (500 + 500 * sqrt2);
|
|
result[1] = (*rand)() * (2000 + 500 * (sqrt2 - 1)) - 2000;
|
|
} while (!in_heart(result));
|
|
return result;
|
|
}
|
|
|
|
double distance(point a, point b) const
|
|
{
|
|
#ifndef BOOST_NO_STDC_NAMESPACE
|
|
using std::sqrt;
|
|
#endif
|
|
if (segment_within_heart(a, b)) {
|
|
// Straight line
|
|
return sqrt((b[0] - a[0]) * (b[0] - a[0]) + (b[1] - a[1]) * (b[1] - a[1]));
|
|
} else {
|
|
// Straight line bending around (0, 0)
|
|
return sqrt(a[0] * a[0] + a[1] * a[1]) + sqrt(b[0] * b[0] + b[1] * b[1]);
|
|
}
|
|
}
|
|
|
|
point move_position_toward(point a, double fraction, point b) const
|
|
{
|
|
#ifndef BOOST_NO_STDC_NAMESPACE
|
|
using std::sqrt;
|
|
#endif
|
|
|
|
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 = sqrt(a[0] * a[0] + a[1] * a[1]);
|
|
double distance_to_point_b = sqrt(b[0] * b[0] + b[1] * 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_GURSOY_ATUN_LAYOUT_HPP
|