ClusterPlanRep.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/HashArray.h>
#include <ogdf/cluster/ClusterArray.h>
#include <ogdf/cluster/ClusterGraph.h>
#include <ogdf/cluster/ClusterGraphAttributes.h>
#include <ogdf/planarity/PlanRep.h>
 
namespace ogdf {
 
 
class OGDF_EXPORT ClusterPlanRep : public PlanRep {
public:
    ClusterPlanRep(const ClusterGraphAttributes& acGraph, const ClusterGraph& clusterGraph);
 
    virtual ~ClusterPlanRep() { }
 
    void initCC(int i);
 
    //edge on the cluster boundary, adjSource
    void setClusterBoundary(edge e) { setEdgeTypeOf(e, edgeTypeOf(e) | clusterPattern()); }
 
    bool isClusterBoundary(edge e) {
        return (edgeTypeOf(e) & clusterPattern()) == clusterPattern();
    }
 
    const ClusterGraph& getClusterGraph() const { return *m_pClusterGraph; }
 
    void insertEdgePathEmbedded(edge eOrig, CombinatorialEmbedding& E,
            const SList<adjEntry>& crossedEdges);
 
    void ModelBoundaries();
 
    //rootadj is set by ModelBoundaries
    adjEntry externalAdj() { return m_rootAdj; }
 
    //structural alterations
 
    virtual void expand(bool lowDegreeExpand = false) override;
 
    virtual void expandLowDegreeVertices(OrthoRep& OR);
 
    virtual edge split(edge e) override {
        edge eNew = PlanRep::split(e);
 
        //update edge to cluster info
        m_edgeClusterID[eNew] = m_edgeClusterID[e];
        m_nodeClusterID[eNew->source()] = m_edgeClusterID[e];
 
        return eNew;
    }
 
    cluster clusterOfEdge(edge e) {
        const auto sourceId = ClusterID(e->source());
        const auto targetId = ClusterID(e->target());
        cluster targetCluster = clusterOfIndex(targetId);
 
        if (sourceId == targetId) {
            return targetCluster;
        }
 
        cluster sourceCluster = clusterOfIndex(sourceId);
 
        if (sourceCluster == targetCluster->parent()) {
            return sourceCluster;
        }
        if (targetCluster == sourceCluster->parent()) {
            return targetCluster;
        }
        if (targetCluster->parent() == sourceCluster->parent()) {
            return sourceCluster->parent();
        }
 
        OGDF_ASSERT(false);
        OGDF_THROW(AlgorithmFailureException);
    }
 
    inline int ClusterID(node v) const { return m_nodeClusterID[v]; }
 
    inline int ClusterID(edge e) const { return m_edgeClusterID[e]; }
 
    cluster clusterOfIndex(int i) {
        OGDF_ASSERT(m_clusterOfIndex.isDefined(i));
        return m_clusterOfIndex[i];
    }
 
    inline cluster clusterOfDummy(node v) {
        OGDF_ASSERT(!original(v));
        OGDF_ASSERT(ClusterID(v) != -1);
        return clusterOfIndex(ClusterID(v));
    }
 
    //output functions
    void writeGML(const char* fileName, const Layout& drawing);
    void writeGML(const char* fileName);
    void writeGML(std::ostream& os, const Layout& drawing);
 
protected:
    void convertClusterGraph(cluster act, AdjEntryArray<edge>& currentEdge,
            AdjEntryArray<int>& outEdge);
 
    void insertBoundary(cluster C, AdjEntryArray<edge>& currentEdge, AdjEntryArray<int>& outEdge,
            bool clusterIsLeaf);
 
    void reinsertEdge(edge e);
 
private:
    const ClusterGraph* m_pClusterGraph;
 
    edgeType clusterPattern() {
        return UMLEdgeTypeConstants::SecCluster << UMLEdgeTypeOffsets::Secondary;
    }
 
    adjEntry m_rootAdj;
 
    EdgeArray<int> m_edgeClusterID;
    NodeArray<int> m_nodeClusterID;
    //we maintain an array of index to cluster mappings (CG is const)
    //cluster numbers don't need to be consecutive
    HashArray<int, cluster> m_clusterOfIndex;
};
 
}