FastHierarchyLayout.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/basic.h>
#include <ogdf/layered/HierarchyLayoutModule.h>
 
namespace ogdf {
class GraphAttributes;
class HierarchyLevelsBase;
template<class E>
class List;
 
class OGDF_EXPORT FastHierarchyLayout : public HierarchyLayoutModule {
protected:
    virtual void doCall(const HierarchyLevelsBase& levels, GraphAttributes& AGC) override;
 
public:
    FastHierarchyLayout();
 
    FastHierarchyLayout(const FastHierarchyLayout&);
 
    // destructor
    virtual ~FastHierarchyLayout() { }
 
    FastHierarchyLayout& operator=(const FastHierarchyLayout&);
 
    double nodeDistance() const { return m_minNodeDist; }
 
    void nodeDistance(double dist) { m_minNodeDist = dist; }
 
    double layerDistance() const { return m_minLayerDist; }
 
    void layerDistance(double dist) { m_minLayerDist = dist; }
 
    bool fixedLayerDistance() const { return m_fixedLayerDist; }
 
    void fixedLayerDistance(bool b) { m_fixedLayerDist = b; }
 
 
private:
    int n; 
    int m; 
    int k; 
    int* layer; 
    int* first; 
 
 
    // nodes are numbered top down and from left to right.
    // Is called "internal numbering".
    // Nodes and Layeras are number 0 to n-1 and 0 to k-1, respectively.
    // For thechnical reasons we set first[k] to n.
 
    List<int>* adj[2];
 
    List<int>** longEdge;
 
    double m_minNodeDist; 
    double m_minLayerDist; 
    double* breadth; 
    double* height; 
    double* y; 
    double* x; 
 
    double* totalB;
 
    double* mDist; 
 
    bool m_fixedLayerDist; 
    bool* virt; 
 
    void incrTo(double& d, double t) {
        if (d < t) {
            d = t;
        }
    }
 
    void decrTo(double& d, double t) {
        if (d > t) {
            d = t;
        }
    }
 
    bool sameLayer(int n1, int n2) const {
        return n1 >= 0 && n1 < n && n2 >= 0 && n2 < n && layer[n1] == layer[n2];
    }
 
    bool isFirst(int actNode) const {
        return actNode < 0 || actNode >= n || actNode == first[layer[actNode]];
    }
 
    bool isLast(int actNode) const {
        return actNode < 0 || actNode >= n || actNode == first[layer[actNode] + 1] - 1;
    }
 
    void sortLongEdges(int actNode, int dir, double* pos, bool& exD, double& dist, int* block,
            bool* marked);
 
    bool placeSingleNode(int leftBnd, int rightBnd, int actNode, double& best, int d);
 
    void placeNodes(int leftBnd, int rightBnd, int left, int right, int d);
 
    void moveLongEdge(int actNode, int dir, bool* marked);
 
    void straightenEdge(int actNode, bool* marked);
 
    void findPlacement();
};
 
}