SugiyamaLayout.h

Go to the documentation of this file.

/*
 * $Revision: 2299 $
 * 
 * last checkin:
 *   $Author: gutwenger $ 
 *   $Date: 2012-05-07 15:57:08 +0200 (Mon, 07 May 2012) $ 
 ***************************************************************/
 
#ifdef _MSC_VER
#pragma once
#endif

#ifndef OGDF_SUGIYAMA_LAYOUT_H
#define OGDF_SUGIYAMA_LAYOUT_H



#include <ogdf/module/LayoutModule.h>
#include <ogdf/module/RankingModule.h>
#include <ogdf/simultaneous/TwoLayerCrossMinSimDraw.h>
#include <ogdf/module/HierarchyLayoutModule.h>
#include <ogdf/module/HierarchyClusterLayoutModule.h>
#include <ogdf/module/CCLayoutPackModule.h>
#include <ogdf/basic/ModuleOption.h>
#include <ogdf/cluster/ClusterGraphAttributes.h>


namespace ogdf {

    class OGDF_EXPORT ExtendedNestingGraph;

class OGDF_EXPORT SugiyamaLayout : public LayoutModule {

protected:

    ModuleOption<RankingModule>                m_ranking;

    ModuleOption<TwoLayerCrossMin>             m_crossMin;

    ModuleOption<TwoLayerCrossMinSimDraw>      m_crossMinSimDraw;

    ModuleOption<HierarchyLayoutModule>        m_layout;

    ModuleOption<HierarchyClusterLayoutModule> m_clusterLayout;

    ModuleOption<CCLayoutPackModule>           m_packer;

    int    m_fails;      
    int    m_runs;       
    bool   m_transpose;  
    bool   m_arrangeCCs; 
    double m_minDistCC;  
    double m_pageRatio;  
    bool   m_permuteFirst;

    int m_nCrossings;    
    RCCrossings m_nCrossingsCluster;
    Array<bool> m_levelChanged;

    bool m_alignBaseClasses; 
    bool m_alignSiblings;    
    
    EdgeArray<unsigned int> *m_subgraphs; 

public:

    SugiyamaLayout();

    // destructor
    ~SugiyamaLayout() { }


    void call(GraphAttributes &AG);

    void call(ClusterGraphAttributes &AG);

    void call(GraphAttributes &AG, NodeArray<int> &rank);

    // special call for UML graphs
    void callUML(GraphAttributes &AG);


    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<unsigned int> *esg) { m_subgraphs = esg; }

    bool useSubgraphs() const { return (m_subgraphs == 0) ? 0 : 1; }


    bool permuteFirst() const { return m_permuteFirst; }
    void permuteFirst(bool b) { m_permuteFirst = b; }


    void setRanking(RankingModule *pRanking) {
        m_ranking.set(pRanking);
    }

    void setCrossMin(TwoLayerCrossMin *pCrossMin) {
        m_crossMin.set(pCrossMin);
    }

    void setLayout(HierarchyLayoutModule *pLayout) {
        m_layout.set(pLayout);
    }

    void setClusterLayout(HierarchyClusterLayoutModule *pLayout) {
        m_clusterLayout.set(pLayout);
    }

    void setPacker(CCLayoutPackModule *pPacker) {
        m_packer.set(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; }

protected:

    void reduceCrossings(Hierarchy &H);
    //void reduceCrossings2(Hierarchy &H);
    void reduceCrossings(ExtendedNestingGraph &H);

private:
    int m_numCC;
    NodeArray<int> m_compGC;

    void doCall(GraphAttributes &AG, bool umlCall);
    void doCall(GraphAttributes &AG, bool umlCall, NodeArray<int> &rank);

    int traverseTopDown (Hierarchy &H);
    int traverseBottomUp(Hierarchy &H);
    //int traverseTopDown2 (Hierarchy &H);
    //int traverseBottomUp2(Hierarchy &H);

    bool transposeLevel(int i, Hierarchy &H);
    void doTranspose(Hierarchy &H);
    void doTransposeRev(Hierarchy &H);

    int m_numLevels;
    int m_maxLevelSize;
    double m_timeReduceCrossings;

    RCCrossings traverseTopDown (ExtendedNestingGraph &H);
    RCCrossings traverseBottomUp(ExtendedNestingGraph &H);

    //NodeArray<double> m_weight;
};


}

#endif