OrthoShaper.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Graph.h>
#include <ogdf/basic/basic.h>
 
namespace ogdf {
class CombinatorialEmbedding;
class OrthoRep;
class PlanRep;
class PlanRepUML;
 
class OGDF_EXPORT OrthoShaper {
public:
    enum class NetworkNodeType { low, high, inner, outer };
 
    OrthoShaper() { setDefaultSettings(); }
 
    ~OrthoShaper() { }
 
    // Given a planar representation for a UML graph and its planar
    // combinatorial embedding, call() produces an orthogonal
    // representation using Tamassias bend minimization algorithm
    // with a flow network where every flow unit defines 90 degree angle
    // in traditional mode.
 
    void call(PlanRepUML& PG, CombinatorialEmbedding& E, OrthoRep& OR, bool fourPlanar = true);
 
    void call(PlanRep& PG, CombinatorialEmbedding& E, OrthoRep& OR, bool fourPlanar = true);
 
    //sets the default settings used in the standard constructor
    void setDefaultSettings() {
        m_distributeEdges = true; // true;  //try to distribute edges to all node sides
        m_fourPlanar = true; //do not allow zero degree angles at high degree
        m_allowLowZero = false; //do allow zero degree at low degree nodes
        m_multiAlign = true; //true;  //start/end side of multi edges match
        m_traditional = true; //true;  //prefer 3/1 flow at degree 2 (false: 2/2)
        m_deg4free = false; //allow free angle assignment at degree four
        m_align = false; //align nodes on same hierarchy level
        m_startBoundBendsPerEdge = 0; //don't use bound on bend number per edge
    }
 
    // returns option distributeEdges
    bool distributeEdges() { return m_distributeEdges; }
 
    // sets option distributeEdges to b
    void distributeEdges(bool b) { m_distributeEdges = b; }
 
    // returns option multiAlign
    bool multiAlign() { return m_multiAlign; }
 
    // sets option multiAlign to b
    void multiAlign(bool b) { m_multiAlign = b; }
 
    // returns option traditional
    bool traditional() { return m_traditional; }
 
    // sets option traditional to b
    void traditional(bool b) { m_traditional = b; }
 
    //returns option deg4free
    bool fixDegreeFourAngles() { return m_deg4free; }
 
    //sets option deg4free
    void fixDegreeFourAngles(bool b) { m_deg4free = b; }
 
    //alignment of brothers in hierarchies
    void align(bool al) { m_align = al; }
 
    bool align() { return m_align; }
 
    void setBendBound(int i) {
        OGDF_ASSERT(i >= 0);
        m_startBoundBendsPerEdge = i;
    }
 
    int getBendBound() { return m_startBoundBendsPerEdge; }
 
private:
    bool m_distributeEdges;
 
    bool m_fourPlanar;
 
    bool m_allowLowZero;
 
    bool m_multiAlign;
 
    bool m_deg4free;
 
    bool m_traditional;
 
    bool m_align;
 
    int m_startBoundBendsPerEdge;
 
    void setAngleBound(edge netArc, int angle, EdgeArray<int>& lowB, EdgeArray<int>& upB,
            EdgeArray<edge>& aTwin, bool maxBound = true) {
        // preliminary
        OGDF_ASSERT(!m_traditional);
 
        const int angleId = angle / 90;
        const edge e2 = aTwin[netArc];
 
        OGDF_ASSERT(angleId >= 0);
        OGDF_ASSERT(angleId <= 2);
 
        if (maxBound) {
            lowB[netArc] = 2 - angleId;
            upB[netArc] = 2;
 
            if (e2) {
                upB[e2] = lowB[e2] = 0;
            }
        } else {
            upB[netArc] = 2 - angleId;
            lowB[netArc] = 0;
 
            if (e2) {
                upB[e2] = 2;
                lowB[e2] = 0;
            }
        }
    }
};
 
}