SugiyamaLayout.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Array.h>
#include <ogdf/basic/Graph.h>
#include <ogdf/basic/LayoutModule.h>
#include <ogdf/basic/basic.h>
#include <ogdf/layered/ExtendedNestingGraph.h>
#include <ogdf/layered/HierarchyClusterLayoutModule.h>
#include <ogdf/layered/HierarchyLayoutModule.h>
#include <ogdf/layered/LayeredCrossMinModule.h>
#include <ogdf/layered/RankingModule.h>
#include <ogdf/packing/CCLayoutPackModule.h>
#include <ogdf/simultaneous/TwoLayerCrossMinSimDraw.h>
 
#include <cstdint>
#include <memory>
 
namespace ogdf {
class ClusterGraphAttributes;
class GraphAttributes;
class Hierarchy;
class HierarchyLevelsBase;
 
class OGDF_EXPORT SugiyamaLayout : public LayoutModule {
#if 0
    class CrossMinMaster;
    class CrossMinWorker;
#endif
 
protected:
    std::unique_ptr<RankingModule> m_ranking;
 
    std::unique_ptr<LayeredCrossMinModule> m_crossMin;
 
    std::unique_ptr<TwoLayerCrossMinSimDraw> m_crossMinSimDraw;
 
    std::unique_ptr<HierarchyLayoutModule> m_layout;
 
    std::unique_ptr<HierarchyClusterLayoutModule> m_clusterLayout;
 
    std::unique_ptr<CCLayoutPackModule> m_packer;
 
    int m_fails; 
    int m_runs; 
    bool m_transpose; 
    bool m_arrangeCCs; 
    double m_minDistCC; 
    double m_pageRatio; 
    bool m_permuteFirst;
    unsigned int m_maxThreads; 
 
    int m_nCrossings; 
    RCCrossings m_nCrossingsCluster;
    Array<bool> m_levelChanged;
 
    bool m_alignBaseClasses; 
    bool m_alignSiblings; 
 
    EdgeArray<uint32_t>* m_subgraphs; 
 
public:
    SugiyamaLayout();
 
    // destructor
    ~SugiyamaLayout() { }
 
    virtual void call(GraphAttributes& GA) override;
 
    void call(ClusterGraphAttributes& CGA);
 
    void call(GraphAttributes& GA, NodeArray<int>& rank);
 
    // special call for UML graphs
    void callUML(GraphAttributes& GA);
 
    int fails() const { return m_fails; }
 
    void fails(int nFails) { m_fails = nFails; }
 
    int runs() const { return m_runs; }
 
    void runs(int nRuns) { m_runs = nRuns; }
 
    bool transpose() const { return m_transpose; }
 
    void transpose(bool bTranspose) { m_transpose = bTranspose; }
 
    bool arrangeCCs() const { return m_arrangeCCs; }
 
    void arrangeCCs(bool bArrange) { m_arrangeCCs = bArrange; }
 
    double minDistCC() const { return m_minDistCC; }
 
    void minDistCC(double x) { m_minDistCC = x; }
 
    double pageRatio() const { return m_pageRatio; }
 
    void pageRatio(double x) { m_pageRatio = x; }
 
    bool alignBaseClasses() const { return m_alignBaseClasses; }
 
    void alignBaseClasses(bool b) { m_alignBaseClasses = b; }
 
    bool alignSiblings() const { return m_alignSiblings; }
 
    void alignSiblings(bool b) { m_alignSiblings = b; }
 
    void setSubgraphs(EdgeArray<uint32_t>* esg) { m_subgraphs = esg; }
 
    bool useSubgraphs() const { return m_subgraphs != nullptr; }
 
    bool permuteFirst() const { return m_permuteFirst; }
 
    void permuteFirst(bool b) { m_permuteFirst = b; }
 
    unsigned int maxThreads() const { return m_maxThreads; }
 
    void maxThreads(unsigned int n) {
#ifndef OGDF_MEMORY_POOL_NTS
        m_maxThreads = n;
#endif
    }
 
    void setRanking(RankingModule* pRanking) { m_ranking.reset(pRanking); }
 
    void setCrossMin(LayeredCrossMinModule* pCrossMin) { m_crossMin.reset(pCrossMin); }
 
    void setLayout(HierarchyLayoutModule* pLayout) { m_layout.reset(pLayout); }
 
    void setClusterLayout(HierarchyClusterLayoutModule* pLayout) { m_clusterLayout.reset(pLayout); }
 
    void setPacker(CCLayoutPackModule* pPacker) { m_packer.reset(pPacker); }
 
    int numberOfCrossings() const { return m_nCrossings; }
 
    RCCrossings numberOfCrossingsCluster() const { return m_nCrossingsCluster; }
 
    int numberOfLevels() { return m_numLevels; }
 
    int maxLevelSize() { return m_maxLevelSize; }
 
    double timeReduceCrossings() { return m_timeReduceCrossings; }
 
    // needed by LayerByLayerSweep::
    const EdgeArray<uint32_t>* subgraphs() const { return m_subgraphs; };
 
    int numCC() const { return m_numCC; };
 
    const NodeArray<int>& compGC() const { return m_compGC; };
 
protected:
#if 0
    void reduceCrossings(HierarchyLevels &levels);
#endif
    void reduceCrossings(ExtendedNestingGraph& H);
 
    const HierarchyLevelsBase* reduceCrossings(Hierarchy& H);
 
private:
    int m_numCC;
    NodeArray<int> m_compGC;
 
    void doCall(GraphAttributes& AG, bool umlCall);
    void doCall(GraphAttributes& AG, bool umlCall, NodeArray<int>& rank);
 
#if 0
    int traverseTopDown(HierarchyLevels &levels);
    int traverseBottomUp(HierarchyLevels &levels);
 
    bool transposeLevel(int i, HierarchyLevels &levels);
    void doTranspose(HierarchyLevels &levels);
    void doTransposeRev(HierarchyLevels &levels);
#endif
 
 
    int m_numLevels;
    int m_maxLevelSize;
    double m_timeReduceCrossings;
 
    RCCrossings traverseTopDown(ExtendedNestingGraph& H);
    RCCrossings traverseBottomUp(ExtendedNestingGraph& H);
};
 
 
}