StressMinimization.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/LayoutModule.h>
#include <ogdf/basic/simple_graph_alg.h>
#include <ogdf/energybased/PivotMDS.h>
#include <ogdf/graphalg/ShortestPathAlgorithms.h>
#include <ogdf/packing/ComponentSplitterLayout.h>
 
namespace ogdf {
 
 
class OGDF_EXPORT StressMinimization : public LayoutModule {
public:
    enum class TerminationCriterion { None, PositionDifference, Stress };
 
    StressMinimization()
        : m_hasEdgeCostsAttribute(false)
        , m_hasInitialLayout(false)
        , m_numberOfIterations(200)
        , m_edgeCosts(100)
        , m_avgEdgeCosts(-1)
        , m_componentLayout(false)
        , m_terminationCriterion(TerminationCriterion::None)
        , m_fixXCoords(false)
        , m_fixYCoords(false)
        , m_fixZCoords(false)
        , m_forcing2DLayout(false)
        , m_use3D(false) { }
 
    ~StressMinimization() { }
 
    virtual void call(GraphAttributes& GA) override;
 
    inline void hasInitialLayout(bool hasInitialLayout);
 
    inline void fixXCoordinates(bool fix);
 
    inline void fixYCoordinates(bool fix);
 
    inline void fixZCoordinates(bool fix);
 
    inline void layoutComponentsSeparately(bool separate);
 
    inline void setEdgeCosts(double edgeCosts);
 
    inline void setIterations(int numberOfIterations);
 
    inline void convergenceCriterion(TerminationCriterion criterion);
 
    inline void useEdgeCostsAttribute(bool useEdgeCostsAttribute);
 
 
    inline void setForcing2DLayout(bool forcing2DLayout);
 
private:
    const static double EPSILON;
 
    const static int DEFAULT_NUMBER_OF_PIVOTS;
 
    bool m_hasEdgeCostsAttribute;
 
    bool m_hasInitialLayout;
 
    int m_numberOfIterations;
 
    double m_edgeCosts;
 
    double m_avgEdgeCosts;
 
    bool m_componentLayout;
 
    TerminationCriterion m_terminationCriterion;
 
    bool m_fixXCoords;
 
    bool m_fixYCoords;
 
    bool m_fixZCoords;
 
    bool m_forcing2DLayout;
 
    bool m_use3D;
 
    double calcStress(const GraphAttributes& GA, NodeArray<NodeArray<double>>& shortestPathMatrix,
            NodeArray<NodeArray<double>>& weightMatrix);
 
    void call(GraphAttributes& GA, NodeArray<NodeArray<double>>& shortestPathMatrix,
            NodeArray<NodeArray<double>>& weightMatrix);
 
    void calcWeights(const Graph& G, NodeArray<NodeArray<double>>& shortestPathMatrix,
            NodeArray<NodeArray<double>>& weightMatrix);
 
    void computeInitialLayout(GraphAttributes& GA);
 
    void copyLayout(const GraphAttributes& GA, NodeArray<double>& newX, NodeArray<double>& newY);
 
    void copyLayout(const GraphAttributes& GA, NodeArray<double>& newX, NodeArray<double>& newY,
            NodeArray<double>& newZ);
 
    bool finished(GraphAttributes& GA, int numberOfPerformedIterations,
            NodeArray<double>& prevXCoords, NodeArray<double>& prevYCoords, const double prevStress,
            const double curStress);
 
    void initMatrices(const Graph& G, NodeArray<NodeArray<double>>& shortestPathMatrix,
            NodeArray<NodeArray<double>>& weightMatrix);
 
    void minimizeStress(GraphAttributes& GA, NodeArray<NodeArray<double>>& shortestPathMatrix,
            NodeArray<NodeArray<double>>& weightMatrix);
 
    void nextIteration(GraphAttributes& GA, NodeArray<NodeArray<double>>& shortestPathMatrix,
            NodeArray<NodeArray<double>>& weightMatrix);
 
    void replaceInfinityDistances(NodeArray<NodeArray<double>>& shortestPathMatrix, double newVal);
};
 
void StressMinimization::fixXCoordinates(bool fix) { m_fixXCoords = fix; }
 
void StressMinimization::fixYCoordinates(bool fix) { m_fixYCoords = fix; }
 
void StressMinimization::hasInitialLayout(bool hasInitialLayout) {
    m_hasInitialLayout = hasInitialLayout;
}
 
void StressMinimization::layoutComponentsSeparately(bool separate) { m_componentLayout = separate; }
 
void StressMinimization::setEdgeCosts(double edgeCosts) {
    m_edgeCosts = (edgeCosts > 0) ? edgeCosts : 100;
}
 
void StressMinimization::setIterations(int numberOfIterations) {
    m_numberOfIterations = (numberOfIterations > 0) ? numberOfIterations : 100;
}
 
void StressMinimization::convergenceCriterion(TerminationCriterion criterion) {
    m_terminationCriterion = criterion;
}
 
void StressMinimization::useEdgeCostsAttribute(bool useEdgeCostsAttribute) {
    m_hasEdgeCostsAttribute = useEdgeCostsAttribute;
}
 
void StressMinimization::setForcing2DLayout(bool forcing2DLayout) {
    m_forcing2DLayout = forcing2DLayout;
}
 
}