source: lemon-0.x/demo/graph_orientation.cc @ 2376:0ed45a6c74b1

/* -*- C++ -*-
 *
 * This file is a part of LEMON, a generic C++ optimization library
 *
 * Copyright (C) 2003-2006
 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 * (Egervary Research Group on Combinatorial Optimization, EGRES).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all copies. For
 * precise terms see the accompanying LICENSE file.
 *
 * This software is provided "AS IS" with no warranty of any kind,
 * express or implied, and with no claim as to its suitability for any
 * purpose.
 *
 */

#include <lemon/list_graph.h>
#include <lemon/graph_reader.h>
#include <lemon/iterable_maps.h>
#include <lemon/dim2.h>
#include <lemon/graph_to_eps.h>


using namespace lemon;
 
GRAPH_TYPEDEFS(ListGraph)

int main(int argc, char** argv) 
{
  if(argc!=2) {
    std::cerr << "\n  USAGE: " << argv[0]
              << " input_file.lgf" << std::endl << std::endl;
    std::cerr << "  The file 'input_file.lgf' has to contain "
              << "at least three node maps called \n  'f', 'coordinates_x' "
              << "and 'coordinates_y'.\n"
              << "  The in-degree requirement is given by 'f', while the two "
              << "others is used\n  to create to output drawing."
              << std::endl;
    return 1;
  }
  
  ListGraph g;

  ListGraph::NodeMap<int> f(g); //in-deg requirement;
  ListGraph::NodeMap<int> label(g);
  ListGraph::NodeMap<dim2::Point<double> > coords(g);
  
  try {
    GraphReader<ListGraph> reader(argv[1],g);
    reader.readNodeMap("f",f);
    reader.readNodeMap("label",label);
    reader.readNodeMap("coordinates_x",xMap(coords));
    reader.readNodeMap("coordinates_y",yMap(coords));
    reader.run();
  } catch (DataFormatError& error) {
    std::cerr << error.what() << std::endl;
    return 1;
  }

  
  ListGraph::NodeMap<int> level(g,0);
  
  ListGraph::NodeMap<int> def(g); //deficiency of the nodes
  def = subMap(f,InDegMap<ListGraph>(g));
  
  IterableBoolMap<ListGraph, Node> active(g,false);
  for(NodeIt n(g);n!=INVALID;++n) active[n]=(def[n]>0);
  
  ListGraph::EdgeMap<bool> rev(g,false); // rev[e]==true <=> e is to be 
                                         //                  reversed

  int nodeNum=countNodes(g);
  
  Node act;
  while((act=IterableBoolMap<ListGraph, Node>::TrueIt(active))!=INVALID) {
    std::cout << "Process node " << label[act]
              << " (def=" << def[act]
              << " lev=" << level[act] << "): ";
    OutEdgeIt e(g,act);
    while(e!=INVALID && level[g.target(e)]>=level[act]) ++e;
    if(e!=INVALID) {
      std::cout << " REVERT EDGE " << g.id(e)
                << " (" << label[g.source(e)] << "---"
                << label[g.target(e)] << ")"
                << std::endl;
      if(--def[act]==0) active[act]=false;
      if(++def[g.target(e)]>0) active[g.target(e)]=true;
      g.reverseEdge(e);
      rev[e]=!rev[e];
    }
    else {
      std::cout << " LIFT" << std::endl;
      if(++level[act]>nodeNum) {
        std::cout << "NINCS ILYEN\n";
        return 1;
      }
    }
  }
  
  //Show the graph

  graphToEps(g,"graph_orientation.eps").scaleToA4().
    title("Sample .eps figure (fits to A4)").
    copyright("(C) 2006 LEMON Project").
    absoluteNodeSizes().absoluteEdgeWidths().
    nodeScale(15).
    coords(coords).
    negateY().
    edgeColors(composeMap(Palette(),rev)).
    edgeWidthScale(1).
    nodeTexts(f).nodeTextSize(20).
    drawArrows().arrowWidth(10).arrowLength(10).
    run();

  
} //end of main()