BertaultLayout.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Array2D.h>
#include <ogdf/basic/Graph.h>
#include <ogdf/basic/LayoutModule.h>
#include <ogdf/basic/List.h>
#include <ogdf/basic/basic.h>
#include <ogdf/basic/memory.h>
 
#include <limits>
 
namespace ogdf {
class GraphAttributes;
class GraphCopy;
class PlanRep;
 
class OGDF_EXPORT BertaultLayout : public LayoutModule {
public:
    BertaultLayout();
    ~BertaultLayout();
 
    BertaultLayout(double length,
            int number); // length= desired edge length... number= number of iterations
 
    explicit BertaultLayout(int number); // number= number of iterations
 
 
    virtual void call(GraphAttributes& AG) override;
 
    void setImpred(bool option) { impred = option; };
 
    void iterno(int no) { userIterNo = no; }
 
    int iterno() { return iter_no; }
 
    void reqlength(double length) { userReqLength = length; }
 
    double reqlength() { return req_length; }
 
    void initPositions(GraphAttributes& AG, char c);
 
    int edgeCrossings(GraphAttributes& AG);
 
    double edgelength(GraphAttributes& GA);
 
    double nodeDistribution(GraphAttributes& GA);
 
protected:
    void f_Node_Repulsive(node* v, node* j, GraphAttributes& AG);
 
    void f_Node_Attractive(node* v, node* j, GraphAttributes& AG);
 
    void compute_I(node* v, edge* e, GraphAttributes& AG);
 
    bool i_On_Edge(edge* e, GraphAttributes& AG);
 
    void f_Edge(node* v, edge* e, GraphAttributes& AG);
 
    void r_Calc_On_Edge(node* v, edge* e, GraphAttributes& AG);
 
    void r_Calc_Outside_Edge(node* v, edge* e, GraphAttributes& AG);
 
    void move(node* v, GraphAttributes& AG);
 
    class CCElement {
    public:
        bool root; // denotes if a element is root
        int num; // The number of the connected component represented by    the object
        CCElement* parent; // refers to parent of this object in the heirarchy
        int faceNum; // the index of the face of parent in which it is contained
        List<CCElement*> child; //list of CCElements refering to the CCs which are contained inside this CC
 
        // Initialises the CCElement to the ith CC
        void init(int i) {
            root = false;
            num = i;
            child.clear();
            parent = this;
        }
    };
 
 
private:
    class BertaultSections {
    public:
        double R[9]; 
 
        void initialize() {
            int i;
            for (i = 0; i < 9; i++) {
                R[i] = std::numeric_limits<double>::max();
            }
        }
    };
 
    void preprocess(GraphAttributes& AG);
 
    void labelling(GraphAttributes& AG);
 
    void crossingPlanarize(GraphAttributes& AG);
 
    int insert(CCElement* new1, CCElement* node, GraphAttributes& PAG, PlanRep& PG);
 
    int contained(CCElement* ele1, CCElement* ele2, GraphAttributes& PAG, PlanRep& PG);
 
    void compute(CCElement* element, PlanRep& PG, GraphAttributes& AG1, GraphCopy& G1);
 
    struct proj {
        double x;
        double y;
    } proj;
 
    NodeArray<BertaultSections> sect; 
    NodeArray<double> F_x; 
    NodeArray<double> F_y; 
    double userReqLength; 
    double userIterNo; 
    double req_length; 
    int iter_no; 
    bool impred; 
    Array2D<bool> surr; 
 
    OGDF_NEW_DELETE
};
 
}