PlanRepUML.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Array.h>
#include <ogdf/basic/Graph.h>
#include <ogdf/basic/GraphList.h>
#include <ogdf/basic/SList.h>
#include <ogdf/basic/basic.h>
#include <ogdf/planarity/PlanRep.h>
 
#include <iosfwd>
 
namespace ogdf {
 
class CombinatorialEmbedding;
class GraphAttributes;
class GridLayoutMapped;
class Layout;
class OrthoRep;
class UMLGraph;
 
class OGDF_EXPORT PlanRepUML : public PlanRep {
public:
    explicit PlanRepUML(const UMLGraph& umlGraph);
    explicit PlanRepUML(const GraphAttributes& GA);
 
 
    ~PlanRepUML() { }
 
    void initCC(int i);
 
    bool faceSplitter(edge e) const { return m_faceSplitter[e]; }
 
    void removeFaceSplitter() {
        for (edge e : edges) {
            if (m_faceSplitter[e]) {
                delEdge(e);
            }
        }
    }
 
 
    void setupIncremental(int indexCC, CombinatorialEmbedding& E);
 
    const SList<node>& incrementalMergers(int indexCC) const { return m_incMergers[indexCC]; }
 
 
    //the edges that are embedded next to outgoing generalizations if alignment set
    //attention: this information is NOT updated during graph changes and only
    //to be used during the embedding phase
    bool alignUpward(adjEntry ae) { return m_alignUpward[ae]; }
 
    void alignUpward(adjEntry ae, bool b) { m_alignUpward[ae] = b; }
 
 
    const UMLGraph& getUMLGraph() const { return *m_pUmlGraph; }
 
 
    node insertGenMerger(node v, const SList<edge>& inGens, CombinatorialEmbedding& E);
 
    void expand(bool lowDegreeExpand = false) override;
 
    void expandLowDegreeVertices(OrthoRep& OR, bool alignSmallDegree = false);
 
    void collapseVertices(const OrthoRep& OR, Layout& drawing);
 
 
    virtual edge split(edge e) override {
        edge eNew = PlanRep::split(e);
 
        //check this
        if (m_alignUpward[e->adjSource()]) {
            m_alignUpward[eNew->adjSource()] = true;
        }
        if (m_alignUpward[e->adjTarget()]) {
            m_alignUpward[eNew->adjTarget()] = true;
        }
 
        return eNew;
    }
 
    void writeGML(const char* fileName, const Layout& drawing);
    void writeGML(const char* fileName);
    void writeGML(const char* fileName, GraphAttributes& AG);
 
    void writeGML(std::ostream& os, const Layout& drawing);
    void writeGML(const char* fileName, const OrthoRep& OR, const Layout& drawing);
    void writeGML(std::ostream& os, const OrthoRep& OR, const Layout& drawing);
    void writeGML(const char* fileName, const OrthoRep& OR, const GridLayoutMapped& drawing);
    void writeGML(std::ostream& os, const OrthoRep& OR, const GridLayoutMapped& drawing);
 
 
protected:
    //insert mergers of generalizations in copy
    void prepareIncrementalMergers(int indexCC, CombinatorialEmbedding& E);
 
protected:
    //still some AdjEntry type: used by alignment procedures
    //attention: this information is NOT updated during graph changes and only
    //to be used during the embedding phase
    AdjEntryArray<bool> m_alignUpward;
 
private:
    const UMLGraph* m_pUmlGraph;
 
    EdgeArray<bool> m_faceSplitter;
 
    SListPure<edge> m_mergeEdges;
    Array<SList<node>> m_incMergers; 
};
 
}