UMLGraph.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Graph.h>
#include <ogdf/basic/GraphAttributes.h>
#include <ogdf/basic/SList.h>
#include <ogdf/basic/basic.h>
#include <ogdf/basic/exceptions.h>
#include <ogdf/basic/geometry.h>
 
#include <algorithm>
#include <iosfwd>
 
namespace ogdf {
template<class E>
class List;
 
class OGDF_EXPORT UMLGraph : public GraphAttributes {
public:
    // construction
 
    // Creates a UML graph for no associated graph (default constructor).
    UMLGraph() : GraphAttributes(), m_pG(nullptr), m_hiddenEdges(nullptr) { }
 
    // Creates a UML graph associated with graph \p G.
    explicit UMLGraph(Graph& G, long initAttributes = 0);
 
    virtual ~UMLGraph();
 
    // Initializes the UML graph for graph \p G.
    virtual void init(Graph& G, long initAttr) {
        m_pG = &G;
        GraphAttributes::init(G, initAttr);
        m_hierarchyParent.init(constGraph(), nullptr);
        m_upwardEdge.init(constGraph(), false);
 
        delete m_hiddenEdges;
        m_hiddenEdges = new Graph::HiddenEdgeSet(G);
    }
 
    virtual void init(const Graph& G, long initAttr) override {
        init(const_cast<Graph&>(G), initAttr);
    }
 
 
    void insertGenMergers();
    node doInsertMergers(node v, SList<edge>& inGens);
    void undoGenMergers();
 
 
    void replaceByStar(List<List<node>>& cliques);
 
    void undoStars();
    void undoStar(node center, bool restoreAllEdges);
 
    DRect cliqueRect(node v) { return m_cliqueCircleSize[v]; }
 
    DPoint cliquePos(node v) { return m_cliqueCirclePos[v]; }
 
#if 0
    //compute circle positions for all nodes around center
    //using the ordering given in this UMLGraph, calls
    //ccP(List...)
    //rectMin is a temporary solution until compaction with constraints allows stretching
    //of rect to clique size, it gives the min(w,h) of the given fixed size rect around the clique
    void computeCliquePosition(node center, double rectMin);
    void computeCliquePosition(node center, double rectMin, const adjEntry &startAdj);
#endif
 
    void computeCliquePosition(List<node>& adjNodes, node center, double rectMin = -1.0);
 
    const SListPure<node>& centerNodes() { return m_centerNodes; }
 
    void setDefaultCliqueCenterSize(double i) { m_cliqueCenterSize = max(i, 1.0); }
 
    double getDefaultCliqueCenterSize() { return m_cliqueCenterSize; }
 
    bool isReplacement(edge e) {
        // TODO: check here how to guarantee that value is defined,
        // edgearray is only valid if there are cliques replaced
        return m_replacementEdge[e];
    }
 
 
#if 0
    Graph& pureGraph() const {return *m_pG;}
 
    void setAlign(edge e, bool b) {m_alignEdge[e] = b;}
#endif
 
    void setUpwards(adjEntry a, bool b) { m_upwardEdge[a] = b; }
 
    bool upwards(adjEntry a) const { return m_upwardEdge[a]; }
 
    void writeGML(const char* fileName);
 
    void writeGML(std::ostream& os);
 
    void adjustHierarchyParents();
 
#if 0
    void sortEdgesFromLayout();
#endif
 
    class AssociationClass {
    public:
        explicit AssociationClass(edge e, double width = 1.0, double height = 1.0, double x = 0.0,
                double y = 0.0)
            : m_width(width), m_height(height), m_x(x), m_y(y), m_edge(e), m_node(nullptr) { }
 
        double m_width;
        double m_height;
        double m_x;
        double m_y;
        edge m_edge;
        node m_node;
    };
 
    const SListPure<AssociationClass*>& assClassList() const { return m_assClassList; }
 
    const AssociationClass* assClass(edge e) const { return m_assClass[e]; }
 
    node createAssociationClass(edge e, double width = 1.0, double height = 1.0) {
        AssociationClass* ac = new AssociationClass(e, width, height);
        m_assClass[e] = ac;
        m_assClassList.pushBack(ac);
        //we already insert the node here, but not the edge
        //when we always insert this node here, we can remove the associationclass
        //class and information later on
        node v = m_pG->newNode();
        m_height[v] = ac->m_height;
        m_width[v] = ac->m_width;
        m_associationClassModel[ac->m_edge] = v;
        ac->m_node = v;
        //guarantee correct angle at edge to edge connection
        if (m_attributes & GraphAttributes::nodeType) {
            m_vType[v] = Graph::NodeType::associationClass;
        }
        return v;
    }
 
    //this modelling should only take place in the preprocessing steps
    //of the drawing algorithms?
    void modelAssociationClasses() {
        SListIterator<UMLGraph::AssociationClass*> it = m_assClassList.begin();
        while (it.valid()) {
            modelAssociationClass((*it));
            ++it;
        }
    }
 
    node modelAssociationClass(AssociationClass* ac) {
        node dummy = m_pG->split(ac->m_edge)->source();
 
        m_height[dummy] = 1; //just a dummy size
        m_width[dummy] = 1;
        OGDF_ASSERT(ac->m_node);
        m_pG->newEdge(ac->m_node, dummy);
 
        return dummy;
    }
 
    void undoAssociationClasses() {
        SListIterator<UMLGraph::AssociationClass*> it = m_assClassList.begin();
        while (it.valid()) {
            undoAssociationClass((*it));
            ++it;
        }
    }
 
    void undoAssociationClass(AssociationClass* ac) {
        node v = m_associationClassModel[ac->m_edge];
        OGDF_ASSERT(v);
        OGDF_ASSERT(v->degree() == 1);
        if (v->degree() != 1) {
            throw AlgorithmFailureException(AlgorithmFailureCode::Label);
        }
        //save layout information
        ac->m_x = x(v);
        ac->m_y = y(v);
 
        //remove node and unsplit edge
 
        //run around the dummy node connected to v
        adjEntry outAdj = v->firstAdj();
        adjEntry dummyAdj = outAdj->twin();
 
        node dummy = dummyAdj->theNode();
        OGDF_ASSERT(dummy->degree() == 3);
 
        //we do not delete the node if we already inserted it in create...
        //because it is a part of the graph now (in contrast to the split node)
        m_pG->delEdge(v->firstAdj()->theEdge());
        OGDF_ASSERT(v->degree() == 0);
 
        m_pG->unsplit(dummy);
    }
 
protected:
 
    node replaceByStar(List<node>& clique, NodeArray<int>& cliqueNum);
    DRect circularBound(node center);
 
 
private:
    Graph* m_pG;
 
 
    //information about edges that are deleted in clique processing
#if 0
    class CliqueInfo {
    public:
        CliqueInfo(node v, int i) : m_target(v), m_edgeIndex(i) {}
        node m_target;    //target node of deleted edge
        int  m_edgeIndex; //index of deleted edge, has to be restored
    };
#endif
 
    double m_cliqueCenterSize; 
    SListPure<node> m_centerNodes; 
 
    EdgeArray<bool> m_replacementEdge; // XXX: maybe we can join this with edge type
    NodeArray<DRect> m_cliqueCircleSize;
    NodeArray<DPoint> m_cliqueCirclePos;
 
 
    SListPure<edge> m_mergeEdges;
    //structures for association classes
    //may be replaced later by generic structures for different types
    SListPure<AssociationClass*> m_assClassList; 
    EdgeArray<AssociationClass*> m_assClass; 
    EdgeArray<node> m_associationClassModel; 
 
 
    AdjEntryArray<bool> m_upwardEdge;
 
    NodeArray<node> m_hierarchyParent;
 
 
    Graph::HiddenEdgeSet* m_hiddenEdges;
};
 
}