PivotMDS.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/LayoutModule.h>
#include <ogdf/basic/simple_graph_alg.h>
#include <ogdf/graphalg/ShortestPathAlgorithms.h>
 
namespace ogdf {
 
template<typename T>
inline bool isinf(T value) {
    return std::numeric_limits<T>::has_infinity && value == std::numeric_limits<T>::infinity();
}
 
 
class OGDF_EXPORT PivotMDS : public LayoutModule {
public:
    PivotMDS()
        : m_numberOfPivots(250)
        , m_dimensionCount(2)
        , m_edgeCosts(100)
        , m_hasEdgeCostsAttribute(false)
        , m_forcing2DLayout(false) { }
 
    virtual ~PivotMDS() { }
 
    void setNumberOfPivots(int numberOfPivots) {
        m_numberOfPivots = std::max(numberOfPivots, m_dimensionCount);
    }
 
    void setEdgeCosts(double edgeCosts) { m_edgeCosts = edgeCosts; }
 
    void setForcing2DLayout(bool forcing2DLayout) { m_forcing2DLayout = forcing2DLayout; }
 
    bool isForcing2DLayout() const { return m_forcing2DLayout; }
 
 
    virtual void call(GraphAttributes& GA) override;
 
    void useEdgeCostsAttribute(bool useEdgeCostsAttribute) {
        m_hasEdgeCostsAttribute = useEdgeCostsAttribute;
    }
 
    bool useEdgeCostsAttribute() const { return m_hasEdgeCostsAttribute; }
 
private:
    const static double EPSILON;
 
    const static double FACTOR;
 
    const static unsigned int SEED = 0;
 
    int m_numberOfPivots;
 
    int m_dimensionCount;
 
    double m_edgeCosts;
 
    bool m_hasEdgeCostsAttribute;
 
    bool m_forcing2DLayout;
 
    void centerPivotmatrix(Array<Array<double>>& pivotMatrix);
 
    void pivotMDSLayout(GraphAttributes& GA);
 
    void copySPSS(Array<double>& copyTo, NodeArray<double>& copyFrom);
 
    void doPathLayout(GraphAttributes& GA, const node& v);
 
    void eigenValueDecomposition(Array<Array<double>>& K, Array<Array<double>>& eVecs,
            Array<double>& eValues);
 
    void getPivotDistanceMatrix(const GraphAttributes& GA, Array<Array<double>>& pivDistMatrix);
 
    node getRootedPath(const Graph& G);
 
    double normalize(Array<double>& x);
 
    double prod(const Array<double>& x, const Array<double>& y);
 
    void randomize(Array<Array<double>>& matrix);
 
    void selfProduct(const Array<Array<double>>& d, Array<Array<double>>& result);
 
    void singularValueDecomposition(Array<Array<double>>& K, Array<Array<double>>& eVecs,
            Array<double>& eVals);
};
 
}