FastSimpleHierarchyLayout.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Graph.h>
#include <ogdf/basic/basic.h>
#include <ogdf/layered/CrossingMinInterfaces.h>
#include <ogdf/layered/HierarchyLayoutModule.h>
 
namespace ogdf {
class GraphAttributes;
class GraphCopy;
 
class OGDF_EXPORT FastSimpleHierarchyLayout : public HierarchyLayoutModule {
private:
    double m_minXSep; 
    double m_ySep; 
    bool m_balanced; 
    bool m_downward; 
    bool m_leftToRight; 
 
protected:
    virtual void doCall(const HierarchyLevelsBase& levels, GraphAttributes& AGC) override;
 
public:
 
    FastSimpleHierarchyLayout();
 
 
    FastSimpleHierarchyLayout(const FastSimpleHierarchyLayout&);
 
    // destructor
    virtual ~FastSimpleHierarchyLayout() { }
 
    FastSimpleHierarchyLayout& operator=(const FastSimpleHierarchyLayout&);
 
    double nodeDistance() const { return m_minXSep; }
 
    void nodeDistance(double dist) { m_minXSep = dist; }
 
    double layerDistance() const { return m_ySep; }
 
    void layerDistance(double dist) { m_ySep = dist; }
 
    bool downward() const { return m_downward; }
 
    void downward(bool d) { m_downward = d; }
 
    bool leftToRight() const { return m_leftToRight; }
 
    void leftToRight(bool b) { m_leftToRight = b; }
 
    bool balanced() const { return m_balanced; }
 
    void balanced(bool b) { m_balanced = b; }
 
 
private:
    void markType1Conflicts(const HierarchyLevelsBase& levels, bool downward,
            NodeArray<NodeArray<bool>>& type1Conflicts);
 
    void verticalAlignment(const HierarchyLevelsBase& levels, NodeArray<node>& root,
            NodeArray<node>& align, const NodeArray<NodeArray<bool>>& type1Conflicts,
            const bool downward, const bool leftToRight);
 
    void computeBlockWidths(const GraphCopy& GC, const GraphAttributes& GCA, NodeArray<node>& root,
            NodeArray<double>& blockWidth);
 
    void horizontalCompactation(const NodeArray<node>& align, const HierarchyLevelsBase& levels,
            const NodeArray<node>& root, const NodeArray<double>& blockWidth, NodeArray<double>& x,
            const bool leftToRight, bool downward);
 
    void placeBlock(node v, NodeArray<node>& sink, NodeArray<double>& shift, NodeArray<double>& x,
            const NodeArray<node>& align, const HierarchyLevelsBase& levels,
            const NodeArray<double>& blockWidth, const NodeArray<node>& root, const bool leftToRight);
 
    node virtualTwinNode(const HierarchyLevelsBase& levels, const node v,
            const HierarchyLevelsBase::TraversingDir dir) const;
 
    node pred(const node v, const HierarchyLevelsBase& levels, const bool leftToRight);
};
 
}