display.hpp

#ifndef DISPLAY_HPP
#define DISPLAY_HPP

#include <boost/shared_ptr.hpp>
#include <boost/graph/adjacency_list.hpp>

#include "qdisplay/ImageView.hpp"
#include "qdisplay/Viewer.hpp"
#include "qdisplay/Shape.hpp"
#include "qdisplay/Ellipsoid.hpp"
#include "qdisplay/Line.hpp"
#include "qdisplay/init.hpp"

#include <QGraphicsItem>
#include <QList>

namespace jafar{
namespace graphmap{
namespace display{

class Node;
class Edge;

class Viewer: public QObject
{
    //Q_OBJECT

public:
  Viewer();
  virtual ~Viewer();

  void itemMoved();

  template <typename Graph>
  void bufferize(const Graph& g)
  {
    using namespace boost;
    typedef typename graph_traits<Graph>::edge_iterator Edge;

    // Loop into graph's edges
    Edge ei, ei_end;
    for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
    {
      int from_id = ((g)[source(*ei,g)].getId().second),
          to_id = ((g)[boost::target(*ei,g)].getId()).second;
      if(!existDisplayEdge(from_id,to_id)) // Check if the edge exists
      {
        addDisplayEdge(from_id,to_id); // If not, add new edge to edge display list
      }
    }

  }

  void render();
  void view();

public slots:
  void shuffle();
  void zoomIn();
  void zoomOut();


public:
  //cv::Size _size;
  unsigned int _width;
  unsigned int _height;
  qdisplay::Viewer* _viewer;

protected:

  bool existDisplayEdge(int from_id, int to_id);
  void addDisplayEdge(int from_id, int to_id);

  void timerEvent(QTimerEvent *event);
  void wheelEvent(QWheelEvent *event);
  void drawBackground(QPainter *painter, const QRectF &rect);

  void scaleView(qreal scaleFactor);
  Node* getNodeWithId(int id);

private:
  int timerId;
  std::list<Node*> node_list;
  std::list<Edge*> edge_list;

};

class Edge : public QGraphicsItem
{
public:
  Edge(Node *sourceNode, Node *destNode);

  Node *sourceNode() const;
  Node *destNode() const;

  void adjust();

  enum { Type = UserType + 2 };
  int type() const { return Type; }

protected:
  QRectF boundingRect() const;
  void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);

private:
  Node *source, *dest;
  QPointF sourcePoint;
  QPointF destPoint;
  qreal arrowSize;
};

class Node : public QGraphicsItem
{
public:
  Node(int id, Viewer *graphWidget);

  void addEdge(Edge *edge);
  QList<Edge*> edges() const;

  enum { Type = UserType + 1 };
  int type() const { return Type; }

  void calculateForces();
  bool advance();

  QRectF boundingRect() const;
  QPainterPath shape() const;
  void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);

protected:
  QVariant itemChange(GraphicsItemChange change, const QVariant &value);

  void mousePressEvent(QGraphicsSceneMouseEvent *event);
  void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);

private:
  QList<Edge*> edgeList;
  QPointF newPos;
  Viewer *graph;
public:
  int _id;
};

}
}
}


#endif // DISPLAY_HPP