FastMultipoleEmbedder.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Graph.h>
#include <ogdf/basic/LayoutModule.h>
#include <ogdf/energybased/fast_multipole_embedder/FMEFunc.h>
#include <ogdf/energybased/fast_multipole_embedder/FMEThread.h>
#include <ogdf/energybased/fast_multipole_embedder/GalaxyMultilevel.h>
 
namespace ogdf {
 
 
class OGDF_EXPORT FastMultipoleEmbedder : public LayoutModule {
    using ArrayGraph = fast_multipole_embedder::ArrayGraph;
    using FMEGlobalOptions = fast_multipole_embedder::FMEGlobalOptions;
    using FMEGlobalContext = fast_multipole_embedder::FMEGlobalContext;
    using FMESingleKernel = fast_multipole_embedder::FMESingleKernel;
    using FMEThreadPool = fast_multipole_embedder::FMEThreadPool;
 
public:
    FastMultipoleEmbedder();
 
    ~FastMultipoleEmbedder();
 
    void call(const Graph& G, NodeArray<float>& nodeXPosition, NodeArray<float>& nodeYPosition,
            const EdgeArray<float>& edgeLength, const NodeArray<float>& nodeSize);
 
    void call(GraphAttributes& GA, const EdgeArray<float>& edgeLength,
            const NodeArray<float>& nodeSize);
 
    virtual void call(GraphAttributes& GA) override;
 
    void setNumIterations(uint32_t numIterations) { m_numIterations = numIterations; }
 
    void setMultipolePrec(uint32_t precision) { m_precisionParameter = precision; }
 
    void setRandomize(bool b) { m_randomize = b; }
 
    void setDefaultEdgeLength(float edgeLength) { m_defaultEdgeLength = edgeLength; }
 
    void setDefaultNodeSize(float nodeSize) { m_defaultNodeSize = nodeSize; }
 
    void setNumberOfThreads(uint32_t numThreads) {
#ifndef OGDF_MEMORY_POOL_NTS
        m_maxNumberOfThreads = numThreads;
#endif
    }
 
#if 0
    void setEnablePostProcessing(bool b) { m_doPostProcessing = b; }
#endif
 
private:
    void initOptions();
 
    void runMultipole();
 
    void runSingle();
 
    void run(uint32_t numIterations);
 
    void allocate(uint32_t numNodes, uint32_t numEdges);
 
    void deallocate();
 
    uint32_t m_numIterations;
 
    ArrayGraph* m_pGraph;
 
    FMEThreadPool* m_threadPool;
 
    FMEGlobalOptions* m_pOptions;
 
    uint32_t m_precisionParameter;
 
    bool m_randomize;
 
    float m_defaultEdgeLength;
 
    float m_defaultNodeSize;
 
    uint32_t m_numberOfThreads;
 
    uint32_t m_maxNumberOfThreads;
};
 
 
class OGDF_EXPORT FastMultipoleMultilevelEmbedder : public LayoutModule {
    using GalaxyMultilevel = fast_multipole_embedder::GalaxyMultilevel;
    using GalaxyMultilevelBuilder = fast_multipole_embedder::GalaxyMultilevelBuilder;
 
public:
    FastMultipoleMultilevelEmbedder()
        : m_iMaxNumThreads(1), m_iNumLevels(0), m_multiLevelNumNodesBound(10), m_iCurrentLevelNr(-1) { }
 
    void call(GraphAttributes& GA) override;
 
    void multilevelUntilNumNodesAreLess(int nodesBound) { m_multiLevelNumNodesBound = nodesBound; }
 
    void maxNumThreads(int numThreads) { m_iMaxNumThreads = numThreads; }
 
private:
    void computeAutoEdgeLength(const GraphAttributes& GA, EdgeArray<float>& edgeLength,
            float factor = 1.0f);
 
    void run(GraphAttributes& GA, const EdgeArray<float>& edgeLength);
 
    void createMultiLevelGraphs(Graph* pGraph, GraphAttributes& GA,
            const EdgeArray<float>& edgeLength);
 
    void initFinestLevel(GraphAttributes& GA, const EdgeArray<float>& edgeLength);
 
    void layoutCurrentLevel();
 
    void assignPositionsFromPrevLevel();
 
    void writeCurrentToGraphAttributes(GraphAttributes& GA);
 
    void nextLevel();
 
    void initCurrentLevel();
 
    void deleteMultiLevelGraphs();
 
    void dumpCurrentLevel(const char* filename);
 
    uint32_t numberOfIterationsByLevelNr(uint32_t levelNr);
 
    int m_iMaxNumThreads;
    int m_iNumLevels;
    int m_multiLevelNumNodesBound;
 
    GalaxyMultilevel* m_pCurrentLevel = nullptr;
    GalaxyMultilevel* m_pFinestLevel = nullptr;
    GalaxyMultilevel* m_pCoarsestLevel = nullptr;
 
    Graph* m_pCurrentGraph = nullptr;
    NodeArray<float>* m_pCurrentNodeXPos = nullptr;
    NodeArray<float>* m_pCurrentNodeYPos = nullptr;
    EdgeArray<float>* m_pCurrentEdgeLength = nullptr;
    NodeArray<float>* m_pCurrentNodeSize = nullptr;
    NodeArray<float> m_adjustedNodeSize;
    int m_iCurrentLevelNr;
 
    NodeArray<float>* m_pLastNodeXPos = nullptr;
    NodeArray<float>* m_pLastNodeYPos = nullptr;
};
 
}