RhodeCode

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * Copyright (C) 2003-2008

 * 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.

 *

 */

#ifndef LEMON_GRAPH_TO_EPS_H

#define LEMON_GRAPH_TO_EPS_H

#include<iostream>

#include<fstream>

#include<sstream>

#include<algorithm>

#include<vector>

#ifndef WIN32

#include<sys/time.h>

#include<ctime>

#else

#define WIN32_LEAN_AND_MEAN

#define NOMINMAX

#include<windows.h>

#endif

#include<lemon/math.h>

#include<lemon/core.h>

#include<lemon/dim2.h>

#include<lemon/maps.h>

#include<lemon/color.h>

#include<lemon/bits/bezier.h>

#include<lemon/error.h>

///\ingroup eps_io

///\file

///\brief A well configurable tool for visualizing graphs

namespace lemon {

  namespace _graph_to_eps_bits {

    template<class MT>

    class _NegY {

    public:

      typedef typename MT::Key Key;

      typedef typename MT::Value Value;

      const MT ↦

      int yscale;

      _NegY(const MT &m,bool b) : map(m), yscale(1-b*2) {}

      Value operator[](Key n) { return Value(map[n].x,map[n].y*yscale);}

    };

  }

///Default traits class of GraphToEps

///Default traits class of \ref GraphToEps.

///

///\c G is the type of the underlying graph.

template<class G>

struct DefaultGraphToEpsTraits

{

  typedef G Graph;

  typedef typename Graph::Node Node;

  typedef typename Graph::NodeIt NodeIt;

  typedef typename Graph::Arc Arc;

  typedef typename Graph::ArcIt ArcIt;

  typedef typename Graph::InArcIt InArcIt;

  typedef typename Graph::OutArcIt OutArcIt;

protected:

  bool isInsideNode(dim2::Point<double> p, double r,int t)

  {

    switch(t) {

    case CIRCLE:

    case MALE:

    case FEMALE:

      return p.normSquare()<=r*r;

    case SQUARE:

      return p.x<=r&&p.x>=-r&&p.y<=r&&p.y>=-r;

    case DIAMOND:

      return p.x+p.y<=r && p.x-p.y<=r && -p.x+p.y<=r && -p.x-p.y<=r;

    }

    return false;

  }

public:

  ~GraphToEps() { }

  ///Draws the graph.

  ///Like other functions using

  ///\ref named-templ-func-param "named template parameters",

  ///this function calls the algorithm itself, i.e. in this case

  ///it draws the graph.

  void run() {

    const double EPSILON=1e-9;

    if(dontPrint) return;

    _graph_to_eps_bits::_NegY<typename T::CoordsMapType>

      mycoords(_coords,_negY);

    os << "%!PS-Adobe-2.0 EPSF-2.0\n";

    if(_title.size()>0) os << "%%Title: " << _title << '\n';

     if(_copyright.size()>0) os << "%%Copyright: " << _copyright << '\n';

    os << "%%Creator: LEMON, graphToEps()\n";

    {

#ifndef WIN32

      timeval tv;

      gettimeofday(&tv, 0);

      char cbuf[26];

      ctime_r(&tv.tv_sec,cbuf);

      os << "%%CreationDate: " << cbuf;

#else

      SYSTEMTIME time;

      GetSystemTime(&time);

      if (GetDateFormat(LOCALE_USER_DEFAULT, 0, &time,

          GetTimeFormat(LOCALE_USER_DEFAULT, 0, &time,

          GetDateFormat(LOCALE_USER_DEFAULT, 0, &time,

        os << "%%CreationDate: " << buf1 << ' '

           << buf2 << ' ' << buf3 << std::endl;

      }

#endif

    }

    if (_autoArcWidthScale) {

      double max_w=0;

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

        max_w=std::max(double(_arcWidths[e]),max_w);

      if(max_w>EPSILON) {

        _arcWidthScale/=max_w;

      }

    }

    if (_autoNodeScale) {

      double max_s=0;

      for(NodeIt n(g);n!=INVALID;++n)

        max_s=std::max(double(_nodeSizes[n]),max_s);

      if(max_s>EPSILON) {

        _nodeScale/=max_s;

      }

    }

    double diag_len = 1;

    if(!(_absoluteNodeSizes&&_absoluteArcWidths)) {

      dim2::Box<double> bb;

      for(NodeIt n(g);n!=INVALID;++n) bb.add(mycoords[n]);

      if (bb.empty()) {

        bb = dim2::Box<double>(dim2::Point<double>(0,0));

      }

      diag_len = std::sqrt((bb.bottomLeft()-bb.topRight()).normSquare());

      if(diag_len<EPSILON) diag_len = 1;

      if(!_absoluteNodeSizes) _nodeScale*=diag_len;

      if(!_absoluteArcWidths) _arcWidthScale*=diag_len;

    }

    dim2::Box<double> bb;

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

      double ns=_nodeSizes[n]*_nodeScale;

      dim2::Point<double> p(ns,ns);

      switch(_nodeShapes[n]) {

      case CIRCLE:

      case SQUARE:

      case DIAMOND:

        bb.add(p+mycoords[n]);

        bb.add(-p+mycoords[n]);

        break;

      case MALE:

        bb.add(-p+mycoords[n]);

        bb.add(dim2::Point<double>(1.5*ns,1.5*std::sqrt(3.0)*ns)+mycoords[n]);

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * Copyright (C) 2003-2008

 * 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.

 *

 */

#ifndef LEMON_TIME_MEASURE_H

#define LEMON_TIME_MEASURE_H

///\ingroup timecount

///\file

///\brief Tools for measuring cpu usage

#ifdef WIN32

#define WIN32_LEAN_AND_MEAN

#define NOMINMAX

#include <windows.h>

#include <cmath>

#else

#include <sys/times.h>

#include <sys/time.h>

#endif

#include <string>

#include <fstream>

#include <iostream>

namespace lemon {

  /// \addtogroup timecount

  /// @{

  /// A class to store (cpu)time instances.

  /// This class stores five time values.

  /// - a real time

  /// - a user cpu time

  /// - a system cpu time

  /// - a user cpu time of children

  /// - a system cpu time of children

  ///

  /// TimeStamp's can be added to or substracted from each other and

  /// they can be pushed to a stream.

  ///

  /// In most cases, perhaps the \ref Timer or the \ref TimeReport

  /// class is what you want to use instead.

  class TimeStamp

  {

    double utime;

    double stime;

    double cutime;

    double cstime;

    double rtime;

    void _reset() {

      utime = stime = cutime = cstime = rtime = 0;

    }

  public:

    ///Read the current time values of the process

    void stamp()

    {

#ifndef WIN32

      timeval tv;

      gettimeofday(&tv, 0);