NodeRespecterLayout.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Graph.h>
#include <ogdf/basic/GraphAttributes.h>
#include <ogdf/basic/GraphCopy.h>
#include <ogdf/basic/LayoutModule.h>
#include <ogdf/basic/basic.h>
#include <ogdf/basic/graphics.h>
#include <ogdf/basic/memory.h>
 
#include <algorithm>
#include <cmath>
#include <utility>
 
namespace ogdf {
template<class E, class INDEX>
class ArrayBuffer;
template<class E>
class SListPure;
 
 
class OGDF_EXPORT NodeRespecterLayout : public LayoutModule {
public:
    NodeRespecterLayout();
 
    ~NodeRespecterLayout() { }
 
    virtual void call(GraphAttributes& attr) override;
 
    enum class PostProcessingMode {
        None, 
        KeepMultiEdgeBends, 
        Complete 
    };
 
 
    void setRandomInitialPlacement(bool randomInitialPlacement);
 
    void setPostProcessing(PostProcessingMode postProcessing);
 
    void setBendNormalizationAngle(double bendNormalizationAngle);
 
    void setNumberOfIterations(int numberOfIterations);
 
    void setMinimalTemperature(double minimalTemperature);
 
    void setInitialTemperature(double initialTemperature);
 
    void setTemperatureDecreaseOffset(double temperatureDecreaseOffset);
 
    void setGravitation(double gravitation);
 
    void setOscillationAngle(double oscillationAngle);
 
    void setDesiredMinEdgeLength(double desiredMinEdgeLength);
 
    void setInitDummiesPerEdge(int initDummiesPerEdge);
 
    void setMaxDummiesPerEdge(int maxDummiesPerEdge);
 
    void setDummyInsertionThreshold(double dummyInsertionThreshold);
 
    void setMaxDisturbance(double maxDisturbance);
 
    void setRepulsionDistance(double repulsionDistance);
 
    void setMinDistCC(double minDistCC);
 
    void setPageRatio(double pageRatio);
 
 
    bool getRandomInitialPlacement() const { return m_randomInitialPlacement; }
 
    PostProcessingMode getPostProcessing() const { return m_postProcessing; }
 
    double getBendNormalizationAngle() const { return m_bendNormalizationAngle; }
 
    int getNumberOfIterations() const { return m_numberOfIterations; }
 
    double getMinimalTemperature() const { return m_minimalTemperature; }
 
    double getInitialTemperature() const { return m_initialTemperature; }
 
    double getTemperatureDecreaseOffset() const { return m_temperatureDecreaseOffset; }
 
    double getGravitation() const { return m_gravitation; }
 
    double getOscillationAngle() const { return m_oscillationAngle; }
 
    double getDesiredMinEdgeLength() const { return m_desiredMinEdgeLength; }
 
    int getInitDummiesPerEdge() const { return m_initDummiesPerEdge; }
 
    int getMaxDummiesPerEdge() const { return m_maxDummiesPerEdge; }
 
    double getDummyInsertionThreshold() const { return m_dummyInsertionThreshold; }
 
    double getMaxDisturbance() const { return m_maxDisturbance; }
 
    double getRepulsionDistance() const { return m_repulsionDistance; }
 
    double getMinDistCC() const { return m_minDistCC; }
 
    double getPageRatio() const { return m_pageRatio; }
 
 
private:
 
    bool m_randomInitialPlacement;
 
    PostProcessingMode m_postProcessing;
 
    double m_bendNormalizationAngle;
 
    int m_numberOfIterations;
 
    double m_minimalTemperature;
 
    double m_initialTemperature;
 
    double m_temperatureDecreaseOffset;
 
    double m_gravitation;
 
    double m_oscillationAngle;
 
    double m_desiredMinEdgeLength;
 
    int m_initDummiesPerEdge;
 
    int m_maxDummiesPerEdge;
 
    double m_dummyInsertionThreshold;
 
    double m_maxDisturbance;
 
    double m_repulsionDistance;
 
    double m_minDistCC;
 
    double m_pageRatio;
 
 
    GraphCopy m_copy;
 
    GraphAttributes m_copyAttr;
 
    NodeArray<double> m_impulseX;
 
    NodeArray<double> m_impulseY;
 
    NodeArray<double> m_localTemperature;
 
    NodeArray<double> m_nodeRadius;
 
    EdgeArray<bool> m_hasParEdges;
 
    NodeArray<NodeArray<double>> m_desiredDistance;
 
 
    int m_degreeSum;
 
    double m_barycenterX;
 
    double m_barycenterY;
 
    int m_iterCounter;
 
    double m_globalTemperature;
 
    double m_factor;
 
    double m_cos;
 
 
    void initData();
 
    void freeData();
 
    void createBends(const ArrayBuffer<edge>& origEdges, GraphAttributes& attr);
 
    void updateNodeLoop(SListPure<node>& nodes);
 
    std::pair<double, double> computeImpulse(node v);
 
    void updateNode(node v, std::pair<double, double> newImpulse);
 
    void addDummies(node v, SListPure<node>& nodes);
 
    inline double radius(const GraphAttributes& attr, node v) const {
        switch (attr.shape(v)) {
        case Shape::Pentagon:
        case Shape::Octagon:
        case Shape::Hexagon:
        case Shape::Rhomb:
        case Shape::Ellipse:
            return std::max(attr.height(v), attr.width(v)) / 2.0;
 
        default:
            // For Rect, RoundedRect, Triangle, Trapeze, Parallelogram, InvTriangle,
            // InvTrapeze, InvParallelogram, Image and unknown shapes.
            return std::hypot(attr.height(v), attr.width(v)) / 2.0;
        }
    }
 
    inline bool haveSameOriginalEdge(node v, node w) const {
        if (m_copy.isDummy(v) && m_copy.isDummy(w)) {
            return m_copy.original(v->firstAdj()->theEdge())
                    == m_copy.original(w->firstAdj()->theEdge());
        } else if (m_copy.isDummy(v)) {
            return m_copy.original(v->firstAdj()->theEdge())->isIncident(w);
        } else if (m_copy.isDummy(w)) {
            return m_copy.original(w->firstAdj()->theEdge())->isIncident(v);
        } else {
            return false;
        }
    }
 
    inline double weight(node v) const { return v->degree() / m_degreeSum; }
 
    OGDF_NEW_DELETE
};
 
}