RhodeCode

  ListDigraph::NodeMap<int> hcolors(h);

  ListDigraph::NodeMap<Point> hcoords(h);

  for(int i=0;i<int(paletteW.size());i++) {

    Node n=h.addNode();

    hcoords[n]=Point(1+i%cols,1+i/cols);

        const double BLOCK_SIZE_FACTOR = 2.0;

        const int MIN_BLOCK_SIZE = 10;

                                MIN_BLOCK_SIZE );

      }

        const double MINOR_LIMIT_FACTOR = 0.1;

        const int MIN_MINOR_LIMIT = 3;

                                 MIN_LIST_LENGTH );

        _minor_limit = std::max( int(MINOR_LIMIT_FACTOR * _list_length),

                                 MIN_MINOR_LIMIT );

        const double HEAD_LENGTH_FACTOR = 0.1;

        const int MIN_HEAD_LENGTH = 3;

                                MIN_BLOCK_SIZE );

        _head_length = std::max( int(HEAD_LENGTH_FACTOR * _block_size),

                                 MIN_HEAD_LENGTH );

      }

      // Store the arcs in a mixed order

      int i = 0;

      for (ArcIt e(_graph); e != INVALID; ++e) {

        _arc_ref[i] = e;

double totalLen(){

  double tlen=0;

  for(EdgeIt e(g);e!=INVALID;++e)

  return tlen;

}

      (q.x * q.x + q.y * q.y) * (r.x * p.y - p.x * r.y) +

      (r.x * r.x + r.y * r.y) * (p.x * q.y - q.x * p.y);

  }

  inline bool circle_form(const Point& p, const Point& q, const Point& r) {

    double a = q.x - p.x;

    double b = (q.x - sx) * p.y - (p.x - sx) * q.y;

    double d = (q.x - sx) * (p.x - sx) * (p - q).normSquare();

  }

  struct YLess {

  std::cout << "Number of arcs    : " << countEdges(g) << std::endl;

  double tlen=0;

  for(EdgeIt e(g);e!=INVALID;++e)

  std::cout << "Total arc length  : " << tlen << std::endl;

  if(ap["eps"])