ModularMultilevelMixer.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/LayoutModule.h>
#include <ogdf/basic/basic.h>
#include <ogdf/energybased/multilevel_mixer/InitialPlacer.h>
#include <ogdf/energybased/multilevel_mixer/MultilevelBuilder.h>
 
#include <memory>
 
namespace ogdf {
class GraphAttributes;
class MultilevelGraph;
 
 
class OGDF_EXPORT ModularMultilevelMixer : public LayoutModule {
private:
 
    std::unique_ptr<LayoutModule> m_oneLevelLayoutModule;
 
 
    std::unique_ptr<LayoutModule> m_finalLayoutModule;
 
    std::unique_ptr<MultilevelBuilder> m_multilevelBuilder;
 
    std::unique_ptr<InitialPlacer> m_initialPlacement;
 
    int m_times;
 
    double m_fixedEdgeLength;
 
    double m_fixedNodeSize;
 
    double m_coarseningRatio; 
 
    bool m_levelBound; 
    bool m_randomize; 
 
public:
    enum class erc {
        None, 
        LevelBound 
    };
 
    ModularMultilevelMixer();
 
    void setLevelLayoutModule(LayoutModule* levelLayout) {
        m_oneLevelLayoutModule.reset(levelLayout);
    }
 
    void setFinalLayoutModule(LayoutModule* finalLayout) { m_finalLayoutModule.reset(finalLayout); }
 
    void setMultilevelBuilder(MultilevelBuilder* levelBuilder) {
        m_multilevelBuilder.reset(levelBuilder);
    }
 
    void setInitialPlacer(InitialPlacer* placement) { m_initialPlacement.reset(placement); }
 
    void setLayoutRepeats(int times = 1) { m_times = times; }
 
    void setAllEdgeLengths(double len) { m_fixedEdgeLength = len; }
 
    void setAllNodeSizes(double size) { m_fixedNodeSize = size; }
 
    void setRandomize(bool b) { m_randomize = b; }
 
    void setLevelBound(bool b) { m_levelBound = b; }
 
    void call(GraphAttributes& GA) override;
 
#if 0
    virtual void call(MultilevelGraph &MLG) {
        GraphAttributes GA(MLG.getGraph());
        MLG.exportAttributesSimple(GA);
        call(GA);
        MLG.importAttributesSimple(GA);
    };
#else
    virtual void call(MultilevelGraph& MLG);
#endif
 
    erc errorCode() { return m_errorCode; }
 
    double coarseningRatio() { return m_coarseningRatio; }
 
private:
    erc m_errorCode; 
};
 
}