GEMLayout.h

Go to the documentation of this file.

/*
 * $Revision: 2299 $
 * 
 * last checkin:
 *   $Author: gutwenger $ 
 *   $Date: 2012-05-07 15:57:08 +0200 (Mon, 07 May 2012) $ 
 ***************************************************************/
 
#ifdef _MSC_VER
#pragma once
#endif

#ifndef OGDF_FAST_LAYOUT_H
#define OGDF_FAST_LAYOUT_H

#include <ogdf/module/LayoutModule.h>
#include <ogdf/basic/Math.h>


namespace ogdf {

    class OGDF_EXPORT GraphCopy;
    class OGDF_EXPORT GraphCopyAttributes;

//---------------------------------------------------------
// GEMLayout
//
// Fast force-directed layout algorithm. See
// - A. Frick, A. Ludwig, H. Mehldau: "A Fast Adaptive 
//   Layout Algorithm for Undirected Graphs"
//  
//---------------------------------------------------------


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; 

public:

    GEMLayout();

    GEMLayout(const GEMLayout &fl);

    // destructor
    ~GEMLayout();

    GEMLayout &operator=(const GEMLayout &fl);

    void call(GraphAttributes &GA);

    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, GraphCopyAttributes &AGC,node v);

    void updateNode(GraphCopy &GC, GraphCopyAttributes &AGC,node v);

    OGDF_NEW_DELETE
};

} // end namespace ogdf

#endif