EdgeRouter.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/GridLayout.h>
#include <ogdf/basic/GridLayoutMapped.h>
#include <ogdf/basic/Layout.h>
#include <ogdf/orthogonal/MinimumEdgeDistances.h>
#include <ogdf/orthogonal/OrthoRep.h>
#include <ogdf/orthogonal/edge_router/NodeInfo.h>
#include <ogdf/orthogonal/internal/RoutingChannel.h>
#include <ogdf/planarity/PlanRep.h>
 
namespace ogdf {
 
class OGDF_EXPORT EdgeRouter {
    using NodeInfo = edge_router::NodeInfo;
 
public:
    //constructor
    EdgeRouter() { }
 
    EdgeRouter(PlanRep& pru, OrthoRep& H, GridLayoutMapped& L, CombinatorialEmbedding& E,
            RoutingChannel<int>& rou, MinimumEdgeDistances<int>& med, NodeArray<int>& nodewidth,
            NodeArray<int>& nodeheight);
 
    virtual ~EdgeRouter() { }
 
    void init(PlanRep& pru, RoutingChannel<int>& rou, bool align = false);
 
    void setDistances();
 
    void call();
 
    void call(PlanRep& pru, OrthoRep& H, GridLayoutMapped& L, CombinatorialEmbedding& E,
            RoutingChannel<int>& rou, MinimumEdgeDistances<int>& med, NodeArray<int>& nodewidth,
            NodeArray<int>& nodeheight, bool align = false);
 
    void place(node v /*, int l_sep, int l_overh*/);
 
    void compute_place(node v, NodeInfo& inf /*, int sep = 10.0, int overh = 2*/);
 
    void compute_routing(node v);
 
    void compute_glue_points_y(node v);
 
    void compute_gen_glue_points_y(node v);
 
    void compute_glue_points_x(node& v);
 
    void compute_gen_glue_points_x(node v);
 
    void initialize_node_info(node v, int sep);
 
    int cp_x(adjEntry ae) { return m_acp_x[ae]; }
 
    int cp_y(adjEntry ae) { return m_acp_y[ae]; }
 
    int gp_x(adjEntry ae) { return m_agp_x[ae]; }
 
    int gp_y(adjEntry ae) { return m_agp_y[ae]; }
 
    void addbends(BendString& bs, const char* s2);
 
    edge addRightBend(edge e);
 
    edge addLeftBend(edge e);
 
    adjEntry outEntry(NodeInfo& inf, OrthoDir d, int pos) {
        if (inf.is_in_edge(d, pos)) {
            return (*inf.inList(d).get(pos))->adjTarget();
        } else {
            return (*inf.inList(d).get(pos))->adjSource(); //we only bend on outentries
        }
    }
 
    adjEntry inEntry(NodeInfo& inf, OrthoDir d, int pos) {
        if (inf.is_in_edge(d, pos)) {
            return (*inf.inList(d).get(pos))->adjSource();
        } else {
            return (*inf.inList(d).get(pos))->adjTarget();
        }
    }
 
    void set_position(node v, int x = 0, int y = 0);
 
    void fix_position(node v, int x = 0, int y = 0);
 
 
    void multiDelta();
 
 
    void align(bool b) { m_align = b; }
 
#if 0
    void setOrSep(int sep) {m_hasOrSep = true; m_orSep = sep;}
#endif
 
private:
    enum class BendType {
        BendFree,
        Bend1Left,
        Bend1Right,
        Bend2Left,
        Bend2Right,
        ProbBf,
        ProbB1L,
        ProbB1R,
        ProbB2L,
        ProbB2R
    };
 
    enum class ProcessType {
        unprocessed,
        processed,
        used
    };
 
    PlanRep* m_prup;
    GridLayoutMapped* m_layoutp;
    OrthoRep* m_orp;
    CombinatorialEmbedding* m_comb;
    RoutingChannel<int>* m_rc;
    MinimumEdgeDistances<int>* m_med;
    NodeArray<int>* m_nodewidth;
    NodeArray<int>* m_nodeheight;
 
    NodeArray<NodeInfo> infos; 
 
    int m_sep; 
    int m_overh; 
    double Cconst; 
 
    BendType abendType(adjEntry ae) { return m_abends[ae]; }
 
    void unsplit(edge e1, edge e2);
 
    void set_corners(node v);
 
    int alpha_move(OrthoDir s_to, OrthoDir s_from, node v);
 
    bool m_minDelta;
 
    node oppositeNode(adjEntry ae) { return ae->twinNode(); }
 
    bool oppositeExpander(adjEntry ae) {
        Graph::NodeType nt;
        nt = m_prup->typeOf(oppositeNode(ae));
        return nt == Graph::NodeType::highDegreeExpander || nt == Graph::NodeType::lowDegreeExpander;
    }
 
    //if yes, set its m_oppositeBendType value according to the newly introduced bend
 
 
    int beta_move(OrthoDir s_from, OrthoDir s_to, int move_num, node v);
 
 
    int compute_move(OrthoDir s_from, OrthoDir s_to, int& kflip, node v);
 
    int updateBends(const node v, ListIterator<edge>& it, const bool updateX, const OrthoDir dir,
            const bool bendLeft, const bool bendUp, int pos = 0);
 
    void updateBends(const node v, ListIterator<edge>& it, int& pos, int& lastunbend,
            const bool updateX, const OrthoDir dir, const bool bendLeft, const bool bendUp,
            const bool subtract);
 
    void updateLowerEdgesBends(const node v, ListIterator<edge>& it, int& pos, int& base,
            const bool updateX, const OrthoDir dir, const bool bendLeft);
 
    void updateOneBend(const bool isDoubleBend, const adjEntry adj, const node v, const OrthoDir dir,
            const bool bendLeft, const BendType btSingle, const BendType btDouble) {
        const OrthoDir dirB = bendLeft ? OrthoRep::nextDir(dir) : OrthoRep::prevDir(dir);
        auto& inf = infos[v];
 
        if (isDoubleBend) { // paper E^
            // must be double-bend
            m_abends[adj] = btDouble;
            inf.inc_E(dirB, dir);
        } else {
            // may be single-bend
            m_abends[adj] = btSingle;
            inf.inc_E_hook(dirB, dir);
        }
    }
 
    NodeArray<int> m_newx, m_newy; 
    NodeArray<bool> m_fixed; 
    EdgeArray<int> lowe, uppe, lefte, righte; 
    AdjEntryArray<int> alowe, auppe, alefte, arighte;
    AdjEntryArray<int> m_agp_x, m_agp_y; 
    AdjEntryArray<node> m_cage_point; 
    AdjEntryArray<int> m_acp_x, m_acp_y; 
 
 
    AdjEntryArray<BendType> m_abends;
 
    NodeArray<BendType> m_oppositeBendType;
 
    NodeArray<ProcessType> m_processStatus;
 
    //alignment test
    NodeArray<bool> m_mergerSon; 
    NodeArray<OrthoDir> m_mergeDir; 
    bool m_align;
};
 
}