// 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: Douglas Gregor

//           Andrew Lumsdaine

#ifndef BOOST_GRAPH_KAMADA_KAWAI_SPRING_LAYOUT_HPP

#define BOOST_GRAPH_KAMADA_KAWAI_SPRING_LAYOUT_HPP

#include <boost/graph/graph_traits.hpp>

#include <boost/graph/johnson_all_pairs_shortest.hpp>

#include <boost/type_traits/is_convertible.hpp>

#include <utility>

#include <iterator>

#include <vector>

#include <boost/limits.hpp>

#include <cmath>

namespace boost {

  namespace detail { namespace graph {

    /**

     * Denotes an edge or display area side length used to scale a

     * Kamada-Kawai drawing.

     */

    template<bool Edge, typename T>

    struct edge_or_side

    {

      explicit edge_or_side(T value) : value(value) {}

      T value;

    };

    /**

     * Compute the edge length from an edge length. This is trivial.

     */

    template<typename Graph, typename DistanceMap, typename IndexMap, 

             typename T>

    T compute_edge_length(const Graph&, DistanceMap, IndexMap, 

                          edge_or_side<true, T> length)

    { return length.value; }

    /**

     * Compute the edge length based on the display area side

       length. We do this by dividing the side length by the largest

       shortest distance between any two vertices in the graph.

     */

    template<typename Graph, typename DistanceMap, typename IndexMap, 

             typename T>

    T

    compute_edge_length(const Graph& g, DistanceMap distance, IndexMap index,

                        edge_or_side<false, T> length)

    {

      T result(0);

      typedef typename graph_traits<Graph>::vertex_iterator vertex_iterator;

      for (vertex_iterator ui = vertices(g).first, end = vertices(g).second;

           ui != end; ++ui) {

        vertex_iterator vi = ui;

        for (++vi; vi != end; ++vi) {

          T dij = distance[get(index, *ui)][get(index, *vi)];

          if (dij > result) result = dij;

        }

      }

      return length.value / result;

    }

    /**

     * Implementation of the Kamada-Kawai spring layout algorithm.

     */

    template<typename Graph, typename PositionMap, typename WeightMap,

             typename EdgeOrSideLength, typename Done,

             typename VertexIndexMap, typename DistanceMatrix,

             typename SpringStrengthMatrix, typename PartialDerivativeMap>

    struct kamada_kawai_spring_layout_impl

    {

      typedef typename property_traits<WeightMap>::value_type weight_type;

      typedef std::pair<weight_type, weight_type> deriv_type;

      typedef typename graph_traits<Graph>::vertex_iterator vertex_iterator;

      typedef typename graph_traits<Graph>::vertex_descriptor

        vertex_descriptor;

      kamada_kawai_spring_layout_impl(

        const Graph& g, 

        PositionMap position,

        WeightMap weight, 

        EdgeOrSideLength edge_or_side_length,

        Done done,

        weight_type spring_constant,

        VertexIndexMap index,

        DistanceMatrix distance,

        SpringStrengthMatrix spring_strength,

        PartialDerivativeMap partial_derivatives)

        : g(g), position(position), weight(weight), 

          edge_or_side_length(edge_or_side_length), done(done),

          spring_constant(spring_constant), index(index), distance(distance),

          spring_strength(spring_strength), 

          partial_derivatives(partial_derivatives) {}

      // Compute contribution of vertex i to the first partial

      // derivatives (dE/dx_m, dE/dy_m) (for vertex m)

      deriv_type

      compute_partial_derivative(vertex_descriptor m, vertex_descriptor i)

      {

#ifndef BOOST_NO_STDC_NAMESPACE

        using std::sqrt;

#endif // BOOST_NO_STDC_NAMESPACE

        deriv_type result(0, 0);

        if (i != m) {

          weight_type x_diff = position[m].x - position[i].x;

          weight_type y_diff = position[m].y - position[i].y;

          weight_type dist = sqrt(x_diff * x_diff + y_diff * y_diff);

          result.first = spring_strength[get(index, m)][get(index, i)] 

            * (x_diff - distance[get(index, m)][get(index, i)]*x_diff/dist);

          result.second = spring_strength[get(index, m)][get(index, i)] 

            * (y_diff - distance[get(index, m)][get(index, i)]*y_diff/dist);

        }

        return result;

      }

      // Compute partial derivatives dE/dx_m and dE/dy_m

      deriv_type 

      compute_partial_derivatives(vertex_descriptor m)

      {

#ifndef BOOST_NO_STDC_NAMESPACE

        using std::sqrt;

#endif // BOOST_NO_STDC_NAMESPACE

        deriv_type result(0, 0);

        // TBD: looks like an accumulate to me

        std::pair<vertex_iterator, vertex_iterator> verts = vertices(g);

        for (/* no init */; verts.first != verts.second; ++verts.first) {

          vertex_descriptor i = *verts.first;

          deriv_type deriv = compute_partial_derivative(m, i);

          result.first += deriv.first;

          result.second += deriv.second;

        }

        return result;

      }

      // The actual Kamada-Kawai spring layout algorithm implementation

      bool run()

      {

#ifndef BOOST_NO_STDC_NAMESPACE

        using std::sqrt;

#endif // BOOST_NO_STDC_NAMESPACE

        // Compute d_{ij} and place it in the distance matrix

        if (!johnson_all_pairs_shortest_paths(g, distance, index, weight, 

                                              weight_type(0)))

          return false;

        // Compute L based on side length (if needed), or retrieve L

        weight_type edge_length = 

          detail::graph::compute_edge_length(g, distance, index,

                                             edge_or_side_length);

        // Compute l_{ij} and k_{ij}

        const weight_type K = spring_constant;

        vertex_iterator ui, end = vertices(g).second;

        for (ui = vertices(g).first; ui != end; ++ui) {

          vertex_iterator vi = ui;

          for (++vi; vi != end; ++vi) {

            weight_type dij = distance[get(index, *ui)][get(index, *vi)];

            if (dij == (std::numeric_limits<weight_type>::max)())

              return false;

            distance[get(index, *ui)][get(index, *vi)] = edge_length * dij;

            distance[get(index, *vi)][get(index, *ui)] = edge_length * dij;

            spring_strength[get(index, *ui)][get(index, *vi)] = K/(dij*dij);

            spring_strength[get(index, *vi)][get(index, *ui)] = K/(dij*dij);

          }

        }

        // Compute Delta_i and find max

        vertex_descriptor p = *vertices(g).first;

        weight_type delta_p(0);

        for (ui = vertices(g).first; ui != end; ++ui) {

          deriv_type deriv = compute_partial_derivatives(*ui);

          put(partial_derivatives, *ui, deriv);

          weight_type delta = 

            sqrt(deriv.first*deriv.first + deriv.second*deriv.second);

          if (delta > delta_p) {

            p = *ui;

            delta_p = delta;

          }

        }

        while (!done(delta_p, p, g, true)) {

          // The contribution p makes to the partial derivatives of

          // each vertex. Computing this (at O(n) cost) allows us to

          // update the delta_i values in O(n) time instead of O(n^2)

          // time.

          std::vector<deriv_type> p_partials(num_vertices(g));

          for (ui = vertices(g).first; ui != end; ++ui) {

            vertex_descriptor i = *ui;

            p_partials[get(index, i)] = compute_partial_derivative(i, p);

          }

          do {

            // Compute the 4 elements of the Jacobian

            weight_type dE_dx_dx = 0, dE_dx_dy = 0, dE_dy_dx = 0, dE_dy_dy = 0;

            for (ui = vertices(g).first; ui != end; ++ui) {

              vertex_descriptor i = *ui;

              if (i != p) {

                weight_type x_diff = position[p].x - position[i].x;

                weight_type y_diff = position[p].y - position[i].y;

                weight_type dist = sqrt(x_diff * x_diff + y_diff * y_diff);

                weight_type dist_cubed = dist * dist * dist;

                weight_type k_mi = spring_strength[get(index,p)][get(index,i)];

                weight_type l_mi = distance[get(index, p)][get(index, i)];

                dE_dx_dx += k_mi * (1 - (l_mi * y_diff * y_diff)/dist_cubed);

                dE_dx_dy += k_mi * l_mi * x_diff * y_diff / dist_cubed;

                dE_dy_dx += k_mi * l_mi * x_diff * y_diff / dist_cubed;

                dE_dy_dy += k_mi * (1 - (l_mi * x_diff * x_diff)/dist_cubed);

              }

            }

            // Solve for delta_x and delta_y

            weight_type dE_dx = get(partial_derivatives, p).first;

            weight_type dE_dy = get(partial_derivatives, p).second;

            weight_type delta_x = 

              (dE_dx_dy * dE_dy - dE_dy_dy * dE_dx)

              / (dE_dx_dx * dE_dy_dy - dE_dx_dy * dE_dy_dx);

            weight_type delta_y = 

              (dE_dx_dx * dE_dy - dE_dy_dx * dE_dx)

              / (dE_dy_dx * dE_dx_dy - dE_dx_dx * dE_dy_dy);

            // Move p by (delta_x, delta_y)

            position[p].x += delta_x;

            position[p].y += delta_y;

            // Recompute partial derivatives and delta_p

            deriv_type deriv = compute_partial_derivatives(p);

            put(partial_derivatives, p, deriv);

            delta_p = 

              sqrt(deriv.first*deriv.first + deriv.second*deriv.second);

          } while (!done(delta_p, p, g, false));

          // Select new p by updating each partial derivative and delta

          vertex_descriptor old_p = p;

          for (ui = vertices(g).first; ui != end; ++ui) {

            deriv_type old_deriv_p = p_partials[get(index, *ui)];

            deriv_type old_p_partial = 

              compute_partial_derivative(*ui, old_p);

            deriv_type deriv = get(partial_derivatives, *ui);

            deriv.first += old_p_partial.first - old_deriv_p.first;

            deriv.second += old_p_partial.second - old_deriv_p.second;

            put(partial_derivatives, *ui, deriv);

            weight_type delta = 

              sqrt(deriv.first*deriv.first + deriv.second*deriv.second);

            if (delta > delta_p) {

              p = *ui;

              delta_p = delta;

            }

          }

        }

        return true;

      }

      const Graph& g; 

      PositionMap position;

      WeightMap weight; 

      EdgeOrSideLength edge_or_side_length;

      Done done;

      weight_type spring_constant;

      VertexIndexMap index;

      DistanceMatrix distance;

      SpringStrengthMatrix spring_strength;

      PartialDerivativeMap partial_derivatives;

    };

  } } // end namespace detail::graph

  /// States that the given quantity is an edge length.

  template<typename T> 

  inline detail::graph::edge_or_side<true, T>

  edge_length(T x) 

  { return detail::graph::edge_or_side<true, T>(x); }

  /// States that the given quantity is a display area side length.

  template<typename T> 

  inline detail::graph::edge_or_side<false, T>

  side_length(T x) 

  { return detail::graph::edge_or_side<false, T>(x); }

  /** 

   * \brief Determines when to terminate layout of a particular graph based

   * on a given relative tolerance. 

   */

  template<typename T = double>

  struct layout_tolerance

  {

    layout_tolerance(const T& tolerance = T(0.001))

      : tolerance(tolerance), last_energy((std::numeric_limits<T>::max)()),

        last_local_energy((std::numeric_limits<T>::max)()) { }

    template<typename Graph>

    bool 

    operator()(T delta_p, 

               typename boost::graph_traits<Graph>::vertex_descriptor p,

               const Graph& g,

               bool global)

    {

      if (global) {

        if (last_energy == (std::numeric_limits<T>::max)()) {

          last_energy = delta_p;

          return false;

        }

        T diff = last_energy - delta_p;

        if (diff < T(0)) diff = -diff;

        bool done = (delta_p == T(0) || diff / last_energy < tolerance);

        last_energy = delta_p;

        return done;

      } else {

        if (last_local_energy == (std::numeric_limits<T>::max)()) {

          last_local_energy = delta_p;

          return delta_p == T(0);

        }

        T diff = last_local_energy - delta_p;

        bool done = (delta_p == T(0) || (diff / last_local_energy) < tolerance);

        last_local_energy = delta_p;

        return done;

      }

    }

  private:

    T tolerance;

    T last_energy;

    T last_local_energy;

  };

  /** \brief Kamada-Kawai spring layout for undirected graphs.

   *

   * This algorithm performs graph layout (in two dimensions) for

   * connected, undirected graphs. It operates by relating the layout

   * of graphs to a dynamic spring system and minimizing the energy

   * within that system. The strength of a spring between two vertices

   * is inversely proportional to the square of the shortest distance

   * (in graph terms) between those two vertices. Essentially,

   * vertices that are closer in the graph-theoretic sense (i.e., by

   * following edges) will have stronger springs and will therefore be

   * placed closer together.

   *

   * Prior to invoking this algorithm, it is recommended that the

   * vertices be placed along the vertices of a regular n-sided

   * polygon.

   *

   * \param g (IN) must be a model of Vertex List Graph, Edge List

   * Graph, and Incidence Graph and must be undirected.

   *

   * \param position (OUT) must be a model of Lvalue Property Map,

   * where the value type is a class containing fields @c x and @c y

   * that will be set to the @c x and @c y coordinates of each vertex.

   *

   * \param weight (IN) must be a model of Readable Property Map,

   * which provides the weight of each edge in the graph @p g.

   *

   * \param edge_or_side_length (IN) provides either the unit length

   * @c e of an edge in the layout or the length of a side @c s of the

   * display area, and must be either @c boost::edge_length(e) or @c

   * boost::side_length(s), respectively.

   *

   * \param done (IN) is a 4-argument function object that is passed

   * the current value of delta_p (i.e., the energy of vertex @p p),

   * the vertex @p p, the graph @p g, and a boolean flag indicating

   * whether @p delta_p is the maximum energy in the system (when @c

   * true) or the energy of the vertex being moved. Defaults to @c

   * layout_tolerance instantiated over the value type of the weight

   * map.

   *

   * \param spring_constant (IN) is the constant multiplied by each

   * spring's strength. Larger values create systems with more energy

   * that can take longer to stabilize; smaller values create systems

   * with less energy that stabilize quickly but do not necessarily

   * result in pleasing layouts. The default value is 1.

   *

   * \param index (IN) is a mapping from vertices to index values

   * between 0 and @c num_vertices(g). The default is @c

   * get(vertex_index,g).

   *

   * \param distance (UTIL/OUT) will be used to store the distance

   * from every vertex to every other vertex, which is computed in the

   * first stages of the algorithm. This value's type must be a model

   * of BasicMatrix with value type equal to the value type of the

   * weight map. The default is a a vector of vectors.

   *

   * \param spring_strength (UTIL/OUT) will be used to store the

   * strength of the spring between every pair of vertices. This

   * value's type must be a model of BasicMatrix with value type equal

   * to the value type of the weight map. The default is a a vector of

   * vectors.

   *

   * \param partial_derivatives (UTIL) will be used to store the

   * partial derivates of each vertex with respect to the @c x and @c

   * y coordinates. This must be a Read/Write Property Map whose value

   * type is a pair with both types equivalent to the value type of

   * the weight map. The default is an iterator property map.

   *

   * \returns @c true if layout was successful or @c false if a

   * negative weight cycle was detected.

   */

  template<typename Graph, typename PositionMap, typename WeightMap,

           typename T, bool EdgeOrSideLength, typename Done,

           typename VertexIndexMap, typename DistanceMatrix,

           typename SpringStrengthMatrix, typename PartialDerivativeMap>

  bool 

  kamada_kawai_spring_layout(

    const Graph& g, 

    PositionMap position,

    WeightMap weight, 

    detail::graph::edge_or_side<EdgeOrSideLength, T> edge_or_side_length,

    Done done,

    typename property_traits<WeightMap>::value_type spring_constant,

    VertexIndexMap index,

    DistanceMatrix distance,

    SpringStrengthMatrix spring_strength,

    PartialDerivativeMap partial_derivatives)

  {

    BOOST_STATIC_ASSERT((is_convertible<

                           typename graph_traits<Graph>::directed_category*,

                           undirected_tag*

                         >::value));

    detail::graph::kamada_kawai_spring_layout_impl<

      Graph, PositionMap, WeightMap, 

      detail::graph::edge_or_side<EdgeOrSideLength, T>, Done, VertexIndexMap, 

      DistanceMatrix, SpringStrengthMatrix, PartialDerivativeMap>

      alg(g, position, weight, edge_or_side_length, done, spring_constant,

          index, distance, spring_strength, partial_derivatives);

    return alg.run();

  }

  /**

   * \overload

   */

  template<typename Graph, typename PositionMap, typename WeightMap,

           typename T, bool EdgeOrSideLength, typename Done, 

           typename VertexIndexMap>

  bool 

  kamada_kawai_spring_layout(

    const Graph& g, 

    PositionMap position,

    WeightMap weight, 

    detail::graph::edge_or_side<EdgeOrSideLength, T> edge_or_side_length,

    Done done,

    typename property_traits<WeightMap>::value_type spring_constant,

    VertexIndexMap index)

  {

    typedef typename property_traits<WeightMap>::value_type weight_type;

    typename graph_traits<Graph>::vertices_size_type n = num_vertices(g);

    typedef std::vector<weight_type> weight_vec;

    std::vector<weight_vec> distance(n, weight_vec(n));

    std::vector<weight_vec> spring_strength(n, weight_vec(n));

    std::vector<std::pair<weight_type, weight_type> > partial_derivatives(n);

    return 

      kamada_kawai_spring_layout(

        g, position, weight, edge_or_side_length, done, spring_constant, index,

        distance.begin(),

        spring_strength.begin(),

        make_iterator_property_map(partial_derivatives.begin(), index,

                                   std::pair<weight_type, weight_type>()));

  }

  /**

   * \overload

   */

  template<typename Graph, typename PositionMap, typename WeightMap,

           typename T, bool EdgeOrSideLength, typename Done>

  bool 

  kamada_kawai_spring_layout(

    const Graph& g, 

    PositionMap position,

    WeightMap weight, 

    detail::graph::edge_or_side<EdgeOrSideLength, T> edge_or_side_length,

    Done done,

    typename property_traits<WeightMap>::value_type spring_constant)

  {

    return kamada_kawai_spring_layout(g, position, weight, edge_or_side_length,

                                      done, spring_constant, 

                                      get(vertex_index, g));

  }

  /**

   * \overload

   */

  template<typename Graph, typename PositionMap, typename WeightMap,

           typename T, bool EdgeOrSideLength, typename Done>

  bool 

  kamada_kawai_spring_layout(

    const Graph& g, 

    PositionMap position,

    WeightMap weight, 

    detail::graph::edge_or_side<EdgeOrSideLength, T> edge_or_side_length,

    Done done)

  {

    typedef typename property_traits<WeightMap>::value_type weight_type;

    return kamada_kawai_spring_layout(g, position, weight, edge_or_side_length,

                                      done, weight_type(1)); 

  }

  /**

   * \overload

   */

  template<typename Graph, typename PositionMap, typename WeightMap,

           typename T, bool EdgeOrSideLength>

  bool 

  kamada_kawai_spring_layout(