LongestPathRanking.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/GraphAttributes.h>
#include <ogdf/basic/GraphCopy.h>
#include <ogdf/basic/NodeArray.h>
#include <ogdf/basic/SList.h>
#include <ogdf/basic/tuples.h>
#include <ogdf/layered/AcyclicSubgraphModule.h>
#include <ogdf/layered/RankingModule.h>
 
#include <memory>
 
namespace ogdf {
 
 
class OGDF_EXPORT LongestPathRanking : public RankingModule {
    std::unique_ptr<AcyclicSubgraphModule> m_subgraph; 
    bool m_sepDeg0; 
    bool m_separateMultiEdges; 
    bool m_optimizeEdgeLength; 
    bool m_alignBaseClasses; 
    bool m_alignSiblings; 
 
    int m_offset, m_maxN;
 
    NodeArray<bool> m_isSource, m_finished;
    NodeArray<SListPure<Tuple2<node, int>>> m_adjacent;
    NodeArray<int> m_ingoing;
 
public:
    LongestPathRanking();
 
 
    virtual void call(const Graph& G, NodeArray<int>& rank) override;
 
 
    void call(const Graph& G, const EdgeArray<int>& length, NodeArray<int>& rank);
 
 
    virtual void call(const Graph& G, const EdgeArray<int>& length, const EdgeArray<int>& cost,
            NodeArray<int>& rank) override {
        call(G, length, rank);
    }
 
    void callUML(const GraphAttributes& AG, NodeArray<int>& rank);
 
 
    bool separateDeg0Layer() const { return m_sepDeg0; }
 
    void separateDeg0Layer(bool sdl) { m_sepDeg0 = sdl; }
 
 
    bool separateMultiEdges() const { return m_separateMultiEdges; }
 
    void separateMultiEdges(bool b) { m_separateMultiEdges = b; }
 
 
    bool optimizeEdgeLength() const { return m_optimizeEdgeLength; }
 
    void optimizeEdgeLength(bool b) { m_optimizeEdgeLength = b; }
 
    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 setSubgraph(AcyclicSubgraphModule* pSubgraph) { m_subgraph.reset(pSubgraph); }
 
 
private:
    void doCall(const Graph& G, NodeArray<int>& rank, EdgeArray<bool>& reversed,
            const EdgeArray<int>& length);
 
    void join(GraphCopySimple& GC, NodeArray<node>& superNode,
            NodeArray<SListPure<node>>& joinedNodes, node v, node w);
 
    void dfs(node v);
    void getTmpRank(node v, NodeArray<int>& rank);
    void dfsAdd(node v, NodeArray<int>& rank);
};
 
}