graph.h

#pragma once
#include <QList>
#include <QPoint>
#include <QString>
#include <QVector2D>
#include <QPolygon>

class Node: public QVector2D {
protected: 
    int     degree;
    int     group;
    QString description;
public:
    Node(): QVector2D(), degree(0), group(-1) {};
    Node(double x, double y): QVector2D(x, y), degree(0), group(-1) {};
    ~Node(void) {};
    operator QVector2D()            {return QVector2D(x(), y());};
    void    set(double x, double y) {setX(x); setY(y);};
    void    set(QPointF p)          {setX(p.x()); setY(p.y());};
    void    set(QVector2D p)        {setX(p.x()); setY(p.y());};

    void    setGroup(int g)         {group = g;};
    int     getGroup(void)          {return group;};

    void    increment(void)         {degree++;};
    int     getDegree(void)         {return degree;};
    void    setInfo(QString s)      {description = s;};
    QString info()                  {return description;};
    QString toString()              {return QString("[") += QString::number(x()) += QString(",") += QString::number(y())+= QString("]");};
};

class Edge {
protected:
    Node* node_start;
    Node* node_end;
    QPolygonF subdivisionPoints;
    QPolygonF newSubdivisionPoints;

public:
    Edge() {};
    Edge(Node* n1, Node* n2) {
        node_start  = n1;
        node_end    = n2;
        subdivisionPoints << n1->toPointF() << n2->toPointF();
    };

    ~Edge(void){};

    void setNewSubdivisionPoints(QPolygonF p){newSubdivisionPoints = p;};
    void updateSubdivisionPoints(){subdivisionPoints = newSubdivisionPoints; newSubdivisionPoints = QPolygonF();};

    QPolygonF   getSubdivisionPoints()                  {return subdivisionPoints;};
    void        clearSubdivisionPoints()                {subdivisionPoints.clear();};
    
    Node*       start(void)                             {return node_start;};
    Node*       end(void)                               {return node_end;};
    QVector2D   midPoint(void)                          {return (*start() + *end())/2.0;};
    QVector2D   vector(void)                            {return *end() - *start();};
    double      length(void)                            {return vector().length();};

    void        increaseSubdivisions(void);
    void        increaseSubdivisions(int numSubdivisions);
    double      compatibility(Edge* other);
    QString     toString(void) {return this->start()->toString() + " -> " + this->end()->toString();};
protected:
    /* COMPATIBILITY CALCULATION FUNCTIONS */
    double      compatibility_angular(Edge* other); 
    double      compatibility_scale(Edge* other);
    double      compatibility_positional(Edge* other);
    double      compatibility_visibility(Edge* other);
    double      visibilityFactor(Edge* other);
    QPair<QVector2D,QVector2D> bandOfSight(Edge* other);
};

/*
 * Datastructure for one Graph instance
**/
class Graph {
public:
    Graph(void) {};
    ~Graph(void) {
        qDeleteAll(edges.begin(), edges.end());
        edges.clear();

        qDeleteAll(nodes.begin(), nodes.end());
        nodes.clear();
    };
    void clear(void)    {
        for (int i=0; i<edges.count(); i++)
            delete (edges.takeAt(0));
        edges.clear();

        for (int i=0; i<nodes.count(); i++)
            delete (nodes.takeAt(0));
        nodes.clear();
    }

    QList<Node*>*   getNodes()          {return &nodes;};
    QList<Edge*>*   getEdges()          {return &edges;};
    void            addNode(Node* n)    {nodes<<n;};
    void            addEdge(Edge* e)    {edges<<e;};

protected: 
    QList<Node*>    nodes;
    QList<Edge*>    edges;

public:
    static QVector2D midPoint(QVector2D a, QVector2D b) {return (a + b) / 2.0;};
    static QPointF   midPoint(QPointF a, QPointF b)     {return (a + b) / 2.0;};
};