FastMultipoleEmbedder.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 _FAST_MULTIPOLE_EMBEDDER_H_
#define _FAST_MULTIPOLE_EMBEDDER_H_

#include <ogdf/basic/Graph.h>
#include <ogdf/module/LayoutModule.h>
#include <ogdf/internal/energybased/MultilevelGraph.h>

namespace ogdf {

class ArrayGraph;
class LinearQuadtree;
class LinearQuadtreeExpansion;
class FMEThreadPool;
class FMEThread;
struct FMEGlobalOptions;
class GalaxyMultilevel;

class OGDF_EXPORT FastMultipoleEmbedder : public LayoutModule
{
public:
    FastMultipoleEmbedder();
    
    ~FastMultipoleEmbedder();
    
    //Does not do anything smart, can be safely removed
    //void call(MultilevelGraph &MLG);

    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);

    void call(GraphAttributes &GA);

    void setNumIterations(__uint32 numIterations) { m_numIterations = numIterations; };

    void setMultipolePrec(__uint32 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 numThreads) { m_maxNumberOfThreads = numThreads; };

    //void setEnablePostProcessing(bool b) { m_doPostProcessing = b; };
private:
    void initOptions();

    void runMultipole();

    void runSingle();

    void run(__uint32 numIterations);

    void allocate(__uint32 numNodes, __uint32 numEdges);

    void deallocate();
    
    __uint32 m_numIterations;

    ArrayGraph* m_pGraph;

    FMEThreadPool* m_threadPool;

    FMEGlobalOptions* m_pOptions;

    __uint32 m_precisionParameter;

    bool m_randomize;

    float m_defaultEdgeLength;

    float m_defaultNodeSize;

    __uint32 m_numberOfThreads;
    
    __uint32 m_maxNumberOfThreads;
};


class OGDF_EXPORT FastMultipoleMultilevelEmbedder : public LayoutModule
{
public:
    FastMultipoleMultilevelEmbedder() : m_iMaxNumThreads(1) {}
    void call(GraphAttributes &GA);

    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 String& filename);

    __uint32 numberOfIterationsByLevelNr(__uint32 levelNr);

    int               m_iMaxNumThreads;
    int               m_iNumLevels;
    int               m_multiLevelNumNodesBound;

    GalaxyMultilevel* m_pCurrentLevel;
    GalaxyMultilevel* m_pFinestLevel;
    GalaxyMultilevel* m_pCoarsestLevel;

    Graph*            m_pCurrentGraph;
    NodeArray<float>* m_pCurrentNodeXPos;
    NodeArray<float>* m_pCurrentNodeYPos;
    EdgeArray<float>* m_pCurrentEdgeLength;
    NodeArray<float>* m_pCurrentNodeSize;
    NodeArray<float>  m_adjustedNodeSize;
    int               m_iCurrentLevelNr;

    Graph*            m_pLastGraph;
    NodeArray<float>* m_pLastNodeXPos;
    NodeArray<float>* m_pLastNodeYPos;
};
    
} // end of namespace ogdf

#endif