GEMLayout.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Graph.h>
#include <ogdf/basic/LayoutModule.h>
#include <ogdf/basic/Math.h>
#include <ogdf/basic/basic.h>
#include <ogdf/basic/memory.h>
 
#include <cmath>
#include <random>
 
namespace ogdf {
class GraphAttributes;
class GraphCopy;
 
 
class OGDF_EXPORT GEMLayout : public LayoutModule {
    // algorithm parameters (see below)
 
    int m_numberOfRounds; 
    double m_minimalTemperature; 
    double m_initialTemperature; 
    double m_gravitationalConstant; 
    double m_desiredLength; 
    double m_maximalDisturbance; 
    double m_rotationAngle; 
    double m_oscillationAngle; 
    double m_rotationSensitivity; 
    double m_oscillationSensitivity; 
    int m_attractionFormula; 
    double m_minDistCC; 
    double m_pageRatio; 
 
    // node data used by the algorithm
 
    NodeArray<double> m_impulseX; 
    NodeArray<double> m_impulseY; 
    NodeArray<double> m_localTemperature; 
    NodeArray<double> m_skewGauge; 
 
    // other data used by the algorithm
 
    double m_barycenterX; 
    double m_barycenterY; 
    double m_newImpulseX; 
    double m_newImpulseY; 
    double m_globalTemperature; 
    double m_cos; 
    double m_sin; 
 
    std::minstd_rand m_rng;
 
public:
    GEMLayout();
 
    GEMLayout(const GEMLayout& fl);
 
    // destructor
    ~GEMLayout();
 
    GEMLayout& operator=(const GEMLayout& fl);
 
    virtual void call(GraphAttributes& GA) override;
 
    int numberOfRounds() const { return m_numberOfRounds; }
 
    void numberOfRounds(int n) { m_numberOfRounds = (n < 0) ? 0 : n; }
 
    double minimalTemperature() const { return m_minimalTemperature; }
 
    void minimalTemperature(double x) { m_minimalTemperature = (x < 0) ? 0 : x; }
 
    double initialTemperature() const { return m_initialTemperature; }
 
    void initialTemperature(double x) {
        m_initialTemperature = (x < m_minimalTemperature) ? m_minimalTemperature : x;
    }
 
    double gravitationalConstant() const { return m_gravitationalConstant; }
 
    void gravitationalConstant(double x) { m_gravitationalConstant = (x < 0) ? 0 : x; }
 
    double desiredLength() const { return m_desiredLength; }
 
    void desiredLength(double x) { m_desiredLength = (x < 0) ? 0 : x; }
 
    double maximalDisturbance() const { return m_maximalDisturbance; }
 
    void maximalDisturbance(double x) { m_maximalDisturbance = (x < 0) ? 0 : x; }
 
    double rotationAngle() const { return m_rotationAngle; }
 
    void rotationAngle(double x) {
        if (x < 0) {
            x = 0;
        }
        if (x > Math::pi / 2.0) {
            x = Math::pi / 2.0;
        }
        m_rotationAngle = x;
    }
 
    double oscillationAngle() const { return m_oscillationAngle; }
 
    void oscillationAngle(double x) {
        if (x < 0) {
            x = 0;
        }
        if (x > Math::pi / 2.0) {
            x = Math::pi / 2.0;
        }
        m_oscillationAngle = x;
    }
 
    double rotationSensitivity() const { return m_rotationSensitivity; }
 
    void rotationSensitivity(double x) {
        if (x < 0) {
            x = 0;
        }
        if (x > 1) {
            x = 1;
        }
        m_rotationSensitivity = x;
    }
 
    double oscillationSensitivity() const { return m_oscillationSensitivity; }
 
    void oscillationSensitivity(double x) {
        if (x < 0) {
            x = 0;
        }
        if (x > 1) {
            x = 1;
        }
        m_oscillationSensitivity = x;
    }
 
    int attractionFormula() const { return m_attractionFormula; }
 
    void attractionFormula(int n) {
        if (n == 1 || n == 2) {
            m_attractionFormula = n;
        }
    }
 
    double minDistCC() const { return m_minDistCC; }
 
    void minDistCC(double x) { m_minDistCC = x; }
 
    double pageRatio() const { return m_pageRatio; }
 
    void pageRatio(double x) { m_pageRatio = x; }
 
 
private:
    double length(double x, double y = 0) const { return sqrt(x * x + y * y); }
 
    double weight(node v) const { return (double)(v->degree()) / 2.5 + 1.0; }
 
    void computeImpulse(GraphCopy& GC, GraphAttributes& AGC, node v);
 
    void updateNode(GraphCopy& GC, GraphAttributes& AGC, node v);
 
    OGDF_NEW_DELETE
};
 
}