RhodeCode

    if(countIncEdges(g,n)%2 || countIncEdges(g,n)==0 )

      std::cout << "GEBASZ!!!" << std::endl;

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

    if(g.u(e)==g.v(e))

      std::cout << "LOOP GEBASZ!!!" << std::endl;

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

  std::cout << "Total arc length (euler) : " << totalLen() << std::endl;

  ListGraph::EdgeMap<Arc> enext(g);

  {

    EulerIt<ListGraph> e(g);

    Arc eo=e;

    Arc ef=e;

//     std::cout << "Tour arc: " << g.id(Edge(e)) << std::endl;

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

      {

//         std::cout << "Tour arc: " << g.id(Edge(e)) << std::endl;

        enext[eo]=e;

        eo=e;

      }

    enext[eo]=ef;

  }

  std::cout << "Creating a tour from that..." << std::endl;

  int nnum = countNodes(g);

  int ednum = countEdges(g);

  for(Arc p=enext[EdgeIt(g)];ednum>nnum;p=enext[p])

    {

//       std::cout << "Checking arc " << g.id(p) << std::endl;

      Arc e=enext[p];

      Arc f=enext[e];

      Node n2=g.source(f);

      Node n1=g.oppositeNode(n2,e);

      Node n3=g.oppositeNode(n2,f);

      if(countIncEdges(g,n2)>2)

        {

//           std::cout << "Remove an Arc" << std::endl;

          Arc ff=enext[f];

          g.erase(e);

          g.erase(f);

          if(n1!=n3)

            {

              Arc ne=g.direct(g.addEdge(n1,n3),n1);

              enext[p]=ne;

              enext[ne]=ff;

              ednum--;

            }

          else {

            enext[p]=ff;

            ednum-=2;

          }

        }

    }

  std::cout << "Total arc length (tour) : " << totalLen() << std::endl;

  std::cout << "2-opt the tour..." << std::endl;

  tsp_improve();

  std::cout << "Total arc length (2-opt tour) : " << totalLen() << std::endl;

}

int main(int argc,const char **argv)

{

  ArgParser ap(argc,argv);

//   bool eps;

  bool disc_d, square_d, gauss_d;

//   bool tsp_a,two_a,tree_a;

  int num_of_cities=1;

  double area=1;

  N=100;

//   girth=10;

  std::string ndist("disc");

  ap.refOption("n", "Number of nodes (default is 100)", N)

    .intOption("g", "Girth parameter (default is 10)", 10)

    .refOption("cities", "Number of cities (default is 1)", num_of_cities)

    .refOption("area", "Full relative area of the cities (default is 1)", area)

    .refOption("disc", "Nodes are evenly distributed on a unit disc (default)",disc_d)

    .optionGroup("dist", "disc")

    .refOption("square", "Nodes are evenly distributed on a unit square", square_d)

    .optionGroup("dist", "square")

    .refOption("gauss",

            "Nodes are located according to a two-dim gauss distribution",

            gauss_d)

    .optionGroup("dist", "gauss")

//     .mandatoryGroup("dist")

    .onlyOneGroup("dist")

    .boolOption("eps", "Also generate .eps output (prefix.eps)")

    .boolOption("dir", "Directed digraph is generated (each arcs are replaced by two directed ones)")

    .boolOption("2con", "Create a two connected planar digraph")

    .optionGroup("alg","2con")

    .boolOption("tree", "Create a min. cost spanning tree")

    .optionGroup("alg","tree")

    .boolOption("tsp", "Create a TSP tour")

    .optionGroup("alg","tsp")

    .boolOption("tsp2", "Create a TSP tour (tree based)")

    .optionGroup("alg","tsp2")

    .boolOption("dela", "Delaunay triangulation digraph")

    .optionGroup("alg","dela")

    .onlyOneGroup("alg")

    .boolOption("rand", "Use time seed for random number generator")

    .optionGroup("rand", "rand")

    .intOption("seed", "Random seed", -1)

    .optionGroup("rand", "seed")

    .onlyOneGroup("rand")

    .other("[prefix]","Prefix of the output files. Default is 'lgf-gen-out'")

    .run();

  if (ap["rand"]) {

    int seed = time(0);

    std::cout << "Random number seed: " << seed << std::endl;

    rnd = Random(seed);

  }

  if (ap.given("seed")) {

    int seed = ap["seed"];

    std::cout << "Random number seed: " << seed << std::endl;

    rnd = Random(seed);

  }

  std::string prefix;

  switch(ap.files().size())

    {

    case 0:

      prefix="lgf-gen-out";

      break;

    case 1:

      prefix=ap.files()[0];

      break;

    default:

      std::cerr << "\nAt most one prefix can be given\n\n";

      exit(1);

    }

  double sum_sizes=0;

  std::vector<double> sizes;

  std::vector<double> cum_sizes;

  for(int s=0;s<num_of_cities;s++)

    {

      //         sum_sizes+=rnd.exponential();

      double d=rnd();

      sum_sizes+=d;

      sizes.push_back(d);

      cum_sizes.push_back(sum_sizes);

    }

  int i=0;

  for(int s=0;s<num_of_cities;s++)

    {

      Point center=(num_of_cities==1?Point(0,0):rnd.disc());

      if(gauss_d)

        for(;i<N*(cum_sizes[s]/sum_sizes);i++) {

          Node n=g.addNode();

          nodes.push_back(n);

          coords[n]=center+rnd.gauss2()*area*

            std::sqrt(sizes[s]/sum_sizes);

        }

      else if(square_d)

        for(;i<N*(cum_sizes[s]/sum_sizes);i++) {

          Node n=g.addNode();

          nodes.push_back(n);

          coords[n]=center+Point(rnd()*2-1,rnd()*2-1)*area*

            std::sqrt(sizes[s]/sum_sizes);

        }

      else if(disc_d || true)

        for(;i<N*(cum_sizes[s]/sum_sizes);i++) {

          Node n=g.addNode();

          nodes.push_back(n);

          coords[n]=center+rnd.disc()*area*

            std::sqrt(sizes[s]/sum_sizes);

        }

    }

//   for (ListGraph::NodeIt n(g); n != INVALID; ++n) {

//     std::cerr << coords[n] << std::endl;

//   }

  if(ap["tsp"]) {

    tsp();

    std::cout << "#2-opt improvements: " << tsp_impr_num << std::endl;

  }

  if(ap["tsp2"]) {

    tsp2();

    std::cout << "#2-opt improvements: " << tsp_impr_num << std::endl;

  }

  else if(ap["2con"]) {

    std::cout << "Make triangles\n";

    //   triangle();

    sparseTriangle(ap["g"]);

    std::cout << "Make it sparser\n";

    sparse2(ap["g"]);

  }

  else if(ap["tree"]) {

    minTree();

  }

  else if(ap["dela"]) {

    delaunay();

  }

  std::cout << "Number of nodes    : " << countNodes(g) << std::endl;

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

  double tlen=0;

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

    tlen+=sqrt((coords[g.v(e)]-coords[g.u(e)]).normSquare());

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

  if(ap["eps"])

    graphToEps(g,prefix+".eps").scaleToA4().

      scale(600).nodeScale(.005).arcWidthScale(.001).preScale(false).

  if(ap["dir"])

    DigraphWriter<ListGraph>(g,prefix+".lgf").

      nodeMap("coordinates_x",scaleMap(xMap(coords),600)).

      nodeMap("coordinates_y",scaleMap(yMap(coords),600)).

      run();

  else GraphWriter<ListGraph>(g,prefix+".lgf").

         nodeMap("coordinates_x",scaleMap(xMap(coords),600)).

         nodeMap("coordinates_y",scaleMap(yMap(coords),600)).

         run();

}