RhodeCode

#ifndef LEMON_BEZIER_H

#define LEMON_BEZIER_H

///\ingroup misc

///\file

///\brief Classes to compute with Bezier curves.

///

///Up to now this file is used internally by \ref graph_to_eps.h

#include<lemon/dim2.h>

namespace lemon {

  namespace dim2 {

class BezierBase {

public:

protected:

  static Point conv(Point x,Point y,double t) {return (1-t)*x+t*y;}

};

class Bezier1 : public BezierBase

{

public:

  Point p1,p2;

  Bezier1() {}

  Bezier1(Point _p1, Point _p2) :p1(_p1), p2(_p2) {}

  Point operator()(double t) const

  {

    //    return conv(conv(p1,p2,t),conv(p2,p3,t),t);

    return conv(p1,p2,t);

      typedef typename Parent::Value Value;

      Map(const Graph& _digraph) : Parent(_digraph) {}

      Map(const Graph& _digraph, const Value& _value) 

	: Parent(_digraph, _value) {}

    };

  };

  template <typename Map, typename Enable = void>

  struct MapTraits {

    typedef False ReferenceMapTag;

    typedef typename Map::Key Key;

    typedef typename Map::Value Value;

  };

  template <typename Map>

  struct MapTraits<

    Map, typename enable_if<typename Map::ReferenceMapTag, void>::type > 

  {

    typedef True ReferenceMapTag;

    typedef typename Map::Key Key;

    typedef typename Map::Value Value;

    typedef typename Map::ConstReference ConstReturnValue;

    typedef typename Map::Reference ReturnValue;

    typedef typename Map::ConstReference ConstReference; 

    typedef typename Map::Reference Reference;

 };

  template <typename MatrixMap, typename Enable = void>

  struct MatrixMapTraits {

    typedef False ReferenceMapTag;

    typedef typename MatrixMap::FirstKey FirstKey;

    typedef typename MatrixMap::SecondKey SecondKey;

    typedef typename MatrixMap::Value Value;

  };

  template <typename MatrixMap>

  struct MatrixMapTraits<

    MatrixMap, typename enable_if<typename MatrixMap::ReferenceMapTag, 

                                  void>::type > 

  {

    typedef True ReferenceMapTag;

    typedef typename MatrixMap::FirstKey FirstKey;

    typedef typename MatrixMap::SecondKey SecondKey;

    typedef typename MatrixMap::Value Value;

    typedef typename MatrixMap::ConstReference ConstReturnValue;

    typedef typename MatrixMap::Reference ReturnValue;

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

#define LEMON_DIJKSTRA_H

///\ingroup shortest_path

///\file

///\brief Dijkstra algorithm.

#include <lemon/list_graph.h>

#include <lemon/bin_heap.h>

#include <lemon/bits/path_dump.h>

#include <lemon/bits/invalid.h>

#include <lemon/error.h>

#include <lemon/maps.h>

namespace lemon {

  /// \brief Default OperationTraits for the Dijkstra algorithm class.

  ///  

  /// It defines all computational operations and constants which are

  /// used in the Dijkstra algorithm.

  template <typename Value>

  struct DijkstraDefaultOperationTraits {

    /// \brief Gives back the zero value of the type.

	      os << mycoords[g.source(*e)].x << ' '

		 << mycoords[g.source(*e)].y << ' '

		 << mm.x << ' ' << mm.y << ' '

		 << mycoords[g.target(*e)].x << ' '

		 << mycoords[g.target(*e)].y << ' '

		 << _arcColors[*e].red() << ' '

		 << _arcColors[*e].green() << ' '

		 << _arcColors[*e].blue() << ' '

		 << _arcWidths[*e]*_arcWidthScale << " lb\n";

	    }

	    sw+=_arcWidths[*e]*_arcWidthScale/2.0+_parArcDist;

	  }

	}

      }

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

	if((!_undirected||g.source(e)<g.target(e))&&_arcWidths[e]>0

	  if(_drawArrows) {

	    dim2::Point<double> d(mycoords[g.target(e)]-mycoords[g.source(e)]);

	    double rn=_nodeSizes[g.target(e)]*_nodeScale;

	    int node_shape=_nodeShapes[g.target(e)];

	    double t1=0,t2=1;

	    for(int i=0;i<INTERPOL_PREC;++i)

	      if(isInsideNode((-(t1+t2)/2)*d,rn,node_shape)) t1=(t1+t2)/2;

	      else t2=(t1+t2)/2;

	    double l=std::sqrt(d.normSquare());

	    d/=l;

	    os << l*(1-(t1+t2)/2) << ' '

	       << _arcWidths[e]*_arcWidthScale << ' '

	       << d.x << ' ' << d.y << ' '

	       << mycoords[g.source(e)].x << ' '

	       << mycoords[g.source(e)].y << ' '

	       << _arcColors[e].red() << ' '

	       << _arcColors[e].green() << ' '

	       << _arcColors[e].blue() << " arr\n";

	  else os << mycoords[g.source(e)].x << ' '

		  << mycoords[g.source(e)].y << ' '

		  << mycoords[g.target(e)].x << ' '

		  << mycoords[g.target(e)].y << ' '

		  << _arcColors[e].red() << ' '

		  << _arcColors[e].green() << ' '

		  << _arcColors[e].blue() << ' '

		  << _arcWidths[e]*_arcWidthScale << " l\n";

      os << "grestore\n";

    }

    if(_showNodes) {

      os << "%Nodes:\ngsave\n";

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

	os << mycoords[n].x << ' ' << mycoords[n].y << ' '

	   << _nodeSizes[n]*_nodeScale << ' '

	   << _nodeColors[n].red() << ' '

	   << _nodeColors[n].green() << ' '

	   << _nodeColors[n].blue() << ' ';

	switch(_nodeShapes[n]) {

	case CIRCLE:

	  os<< "nc";break;

	case SQUARE:

	  os<< "nsq";break;

	case DIAMOND:

    Node target(Arc e) const { return Node(arcs[e.id].target); }

    void first(Node& node) const { 

      node.id = first_node;

    }

    void next(Node& node) const {

      node.id = nodes[node.id].next;

    }

    void first(Arc& arc) const { 

      int n;

      for(n = first_node; 

	  n!=-1 && nodes[n].first_in == -1; 

      arc.id = (n == -1) ? -1 : nodes[n].first_in;

    }

    void next(Arc& arc) const {

      if (arcs[arc.id].next_in != -1) {

	arc.id = arcs[arc.id].next_in;

      } else {

	int n;

	for(n = nodes[arcs[arc.id].target].next;

	arc.id = (n == -1) ? -1 : nodes[n].first_in;

      }      

    }

    void firstOut(Arc &e, const Node& v) const {

      e.id = nodes[v.id].first_out;

    }

    void nextOut(Arc &e) const {

      e.id=arcs[e.id].next_out;

    }

    void firstIn(Arc &e, const Node& v) const {

      e.id = nodes[v.id].first_in;

    }

    void nextIn(Arc &e) const {

      e.id=arcs[e.id].next_in;

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

#define LEMON_TEST_TEST_TOOLS_H

///\ingroup misc

///\file

///\brief Some utilities to write test programs.

#include <iostream>

///If \c rc is fail, writes an error message and exits.

///If \c rc is fail, writes an error message and exits.

///The error message contains the file name and the line number of the

///source code in a standard from, which makes it possible to go there

///using good source browsers like e.g. \c emacs.

///

///For example

///\code check(0==1,"This is obviously false.");\endcode will

///print something like this (and then exits).

///\verbatim file_name.cc:123: error: This is obviously false. \endverbatim

#define check(rc, msg) \

  if(!(rc)) { \

    std::cerr << __FILE__ ":" << __LINE__ << ": error: " << msg << std::endl; \

    abort(); \

  } else { } \

#endif