HierarchyLevels.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Array.h>
#include <ogdf/basic/Graph.h>
#include <ogdf/basic/basic.h>
#include <ogdf/basic/memory.h>
#include <ogdf/layered/CrossingMinInterfaces.h>
#include <ogdf/layered/Level.h>
 
#include <cstdint>
#include <iosfwd>
 
namespace ogdf {
class Hierarchy;
 
 
class OGDF_EXPORT HierarchyLevels : public HierarchyLevelsBase {
public:
    friend class Level;
    friend class LayerBasedUPRLayout;
 
private:
    const Hierarchy& m_H;
 
    Array<Level*> m_pLevel; 
    NodeArray<int> m_pos; 
 
    NodeArray<Array<node>> m_lowerAdjNodes; 
    NodeArray<Array<node>> m_upperAdjNodes; 
 
    NodeArray<int> m_nSet; 
 
    TraversingDir m_direction; 
 
public:
    explicit HierarchyLevels(const Hierarchy& H);
    ~HierarchyLevels();
 
    const Hierarchy& hierarchy() const override { return m_H; }
 
    TraversingDir direction() const { return m_direction; }
 
    void direction(TraversingDir dir) { m_direction = dir; }
 
    int size() const override { return m_pLevel.size(); }
 
    int high() const override { return m_pLevel.high(); }
 
    int pos(node v) const override { return m_pos[v]; }
 
    const Array<node>& adjNodes(node v) const {
        return (m_direction == TraversingDir::downward) ? m_lowerAdjNodes[v] : m_upperAdjNodes[v];
    }
 
    const Array<node>& adjNodes(node v, TraversingDir dir) const override {
        return (dir == TraversingDir::downward) ? m_lowerAdjNodes[v] : m_upperAdjNodes[v];
    }
 
    const Level& adjLevel(int i) const {
        return (m_direction == TraversingDir::downward) ? *m_pLevel[i - 1] : *m_pLevel[i + 1];
    }
 
    const Level& operator[](int i) const override { return *m_pLevel[i]; }
 
    Level& operator[](int i) { return *m_pLevel[i]; }
 
    int calculateCrossingsSimDraw(int i, const EdgeArray<uint32_t>* edgeSubGraphs) const;
    int calculateCrossingsSimDraw(const EdgeArray<uint32_t>* edgeSubGraphs) const;
 
    void storePos(NodeArray<int>& oldPos) const;
    void restorePos(const NodeArray<int>& newPos);
 
    void permute();
 
    template<class RNG>
    void permute(RNG& rng);
 
    void separateCCs(int numCC, const NodeArray<int>& component);
 
    bool transpose(node v);
 
    void print(std::ostream& os) const;
 
    void buildAdjNodes(int i);
    void buildAdjNodes();
 
    void check() const;
 
private:
    int transposePart(const Array<node>& adjV, const Array<node>& adjW);
 
    OGDF_MALLOC_NEW_DELETE
};
 
template<class RNG>
void HierarchyLevels::permute(RNG& rng) {
    for (int i = 0; i < m_pLevel.high(); ++i) {
        Level& level = *m_pLevel[i];
        level.m_nodes.permute(rng);
        for (int j = 0; j <= level.high(); ++j) {
            m_pos[level[j]] = j;
        }
    }
 
    buildAdjNodes();
}
 
}