+/*
+ * Everything that needs the Boost Graph Library and C++ templates etc.
+ * (and what a crazy set of stuff that all is)
+ */
+
+#include <math.h>
+
extern "C" {
+#include "bgl.h"
#include "mgraph.h"
+#include "common.h"
}
/*
*/
/*
- * We use BGL's implementation of Johnson All Pairs Shortest Paths
+ * We use BGL's implementation of Dijkstra's single source shortest
+ * paths. We really want all pairs shortest paths, so Johnson All
+ * Pairs Shortest Paths would seem sensible. But actually Johnson's
+ * algorithm is just a wrapper around Dijkstra's; the extra
+ * functionality is just to deal with -ve edge weights, which we don't
+ * have. So we can use Dijkstra directly and save some cpu (and some
+ * code: we don't have to supply all of the machinery needed for
+ * Johnson's invocation of Bellman-Ford). The overall time cost is
+ * O(VE log V); I think the space used is O(E).
*/
#define VMASK (YMASK|XMASK)
#define ESHIFT (YBITS|XBITS)
-/* When we enumerate the edges we mainly just increment f.
- * To avoid nonexistent edges
- * we start with e=0 | y=1 | x=0
- * and explicitly skip e=1 | y=0 | ...
- * We go only up to e=2 | YMAX | XMAX
- * ie we stop just before e=3 | y=0 | x=0
- * so that we get each edge once rather than twice.
- */
-
-#define F_ALL_MIN (1 << YSHIFT)
-#define F_ALL_MAX (3 << ESHIFT)
-#define F_ALL_SKIP_AT (1 << ESHIFT)
-#define F_ALL_SKIP_SET (1 << YSHIFT)
+class Graph { }; // this is a dummy as our graph has no actual representation
namespace boost {
- // We make Layout a model of various BGL Graph concepts.
- // This mainly means that graph_traits<Layout> has lots of stuff.
+ // We make Graph a model of various BGL Graph concepts.
+ // This mainly means that graph_traits<Graph> has lots of stuff.
// First, some definitions used later:
OutEdgeIncrable& operator++() { f += 1<<ESHIFT; return self; }
OutEdgeIncrable(int v, int e) : f(v | (e << ESHIFT)) { }
};
- struct AnyEdgeIncrable {
- int f;
- AnyEdgeIncrable& operator++() {
- f++;
- if (f == F_ALL_SKIP_AT) f |= F_ALL_SKIP_SET
- return self;
- }
- AnyEdgeIncrable(int _f) : f(_f) { }
- AnyEdgeIncrable() : f(F_ALL_MIN) { }
- };
- struct graph_traits<Layout> {
+ struct graph_traits<Graph> {
// Concept Graph:
forward_iterator_tag> out_edge_iterator;
typedef int degree_size_type;
- inline int source(int f, const Layout&) { return f&VMASK; }
- inline int target(int f, const Layout&) { return EDGE_END2(f&VMASK, f>>ESHIFT); }
+ inline int source(int f, const Graph&) { return f&VMASK; }
+ inline int target(int f, const Graph&) { return EDGE_END2(f&VMASK, f>>ESHIFT); }
inline std::pair<out_edge_iterator,out_edge_iterator>
- out_edges(int v, const Layout&) {
+ out_edges(int v, const Graph&) {
return std::make_pair(out_edge_iterator(OutEdgeIncrable(v, VE_MIN(v))),
out_edge_iterator(OutEdgeIncrable(v, VE_MAX(v))));
}
- out_degree(int v, const Layout&) { return VE_MAX(v) - VE_MIN(v); }
+ inline out_degree(int v, const Graph&) { return VE_MAX(v) - VE_MIN(v); }
// Concept VertexListGraph:
typedef counting_iterator<int> vertex_iterator;
typedef unsigned vertices_size_type;
inline std::pair<vertex_iterator,vertex_iterator>
- vertices(const Layout&) {
+ vertices(const Graph&) {
return std::make_pair(vertex_iterator(0), vertex_iterator(N));
}
- inline unsigned num_vertices(const Layout&) { return N; }
+ inline unsigned num_vertices(const Graph&) { return N; }
+ };
+};
- // Concept EdgeListGraph:
- typedef counting_iterator<AnyEdgeIncrable,
- forward_iterator_tag> edge_iterator;
- typedef unsigned edges_size_type;
- inline std::pair<edge_iterator,edge_iterator>
- edges(const Layout&) {
- return std::make_pair(edge_iterator(AnyEdgeIncrable()),
- edge_iterator(AnyEdgeIncrable(F_ALL_MAX)));
- }
- unsigned num_edges(const Layout&) {
- return F_ALL_MAX - F_ALL_MIN - ((F_SKIP_SET|F_SKIP_AT) - F_SKIP_AT);
- }
-
-}
+static void single_source_shortest_paths(int v1,
+ const double edge_weights[/*f*/],
+ double vertex_distances[/*v*/]) {
+ Graph g;
-void calculate_layout_energy(const Layout*) {
-
- FOR_VERTEX(v1) {
- boost::dijkstra_shortest_paths(g, v1, 0);
+ boost::dijkstra_shortest_paths(g, v1,
+ weight_map(edge_weights).
+ vertex_index_map(identity_property_map()).
+ distance_map(vertex_distances));
+}
- /* weight_map(). ? */
- /* vertex_index_map(vimap). */
-
-
- predecessor_map().
- distance_map()
-
+double graph_layout_cost(const Vertices v, const double vertex_areas[N]) {
+ /* For each (vi,vj) computes shortest path s_ij = |vi..vj|
+ * along edges, and actual distance d_ij = |vi-vj|.
+ *
+ * We will also use the `vertex areas': for each vertex vi the
+ * vertex area a_vi is the mean area of the incident triangles.
+ * This is computed elsewhere.
+ *
+ * Energy contribution is proportional to
+ *
+ * -4 2
+ * a a . d . [ (s/d) - 1 ]
+ * vi vj
+ *
+ * (In practice we compute d^2+epsilon and use it for the
+ * divisions, to avoid division by zero.)
+ */
+ static const d2_epsilon= 1e-6;
+
+ double edge_weights[N*V6], vertex_distances[N], total_cost;
+ int v1,v2,e,f;
+ FOR_VEDGE_X(v1,e,v2,
+ f= v1 | e << ESHIFT,
+ edge_weights[f]= NaN)
+ edge_weights[f]= hypotD(v[v1], v[v2]);
+ FOR_VERTEX(v1) {
+ double a1= vertex_areas[v1];
+ single_source_shortest_paths(v1, edge_weights, vertex_distances);
+ FOR_VERTEX(v2) {
+ double a2= vertex_areas[v2];
+ double d2= hypotD2plus(v[v1],v[v2], d2_epsilon);
+ double sd= vertex_distances[v2] / d2;
+ double sd2= sd*sd;
+ total_cost += a1*a2 * (sd2 - 1) / (d2*d2);
+ }
+ }
+ return total_cost;
+}
~ian / moebius2.git / blobdiff