UpwardPlanarizationLayout.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Graph.h>
#include <ogdf/basic/GraphAttributes.h>
#include <ogdf/basic/LayoutModule.h>
#include <ogdf/upward/LayerBasedUPRLayout.h>
#include <ogdf/upward/SubgraphUpwardPlanarizer.h>
#include <ogdf/upward/UPRLayoutModule.h>
#include <ogdf/upward/UpwardPlanRep.h>
#include <ogdf/upward/UpwardPlanarizerModule.h>
 
#include <memory>
 
namespace ogdf {
 
class UpwardPlanarizationLayout : public LayoutModule {
public:
    // constructor: sets options to default values
    UpwardPlanarizationLayout() {
        m_cr_nr = 0;
        // set default module
        m_layout.reset(new LayerBasedUPRLayout());
        m_UpwardPlanarizer.reset(new SubgraphUpwardPlanarizer());
    }
 
    // calls the algorithm for attributed graph GA
    // returns layout information in GA
    virtual void call(GraphAttributes& GA) override {
        if (GA.constGraph().numberOfNodes() > 2) {
            UpwardPlanRep UPR;
            UPR.setOriginalGraph(GA.constGraph());
            m_UpwardPlanarizer->call(UPR);
            m_layout->call(UPR, GA);
            m_cr_nr = UPR.numberOfCrossings();
            m_numLevels = m_layout->numberOfLevels;
        }
    }
 
    // module option for the computation of the final layout
    void setUPRLayout(UPRLayoutModule* pLayout) { m_layout.reset(pLayout); }
 
    void setUpwardPlanarizer(UpwardPlanarizerModule* pUpwardPlanarizer) {
        m_UpwardPlanarizer.reset(pUpwardPlanarizer);
    }
 
    // returns the number of crossings in the layout after the algorithm
    // has been applied
    int numberOfCrossings() const { return m_cr_nr; }
 
    int numberOfLevels() const { return m_numLevels; }
 
protected:
    int m_cr_nr;
    int m_numLevels;
    std::unique_ptr<UpwardPlanarizerModule> m_UpwardPlanarizer;
    std::unique_ptr<UPRLayoutModule> m_layout;
};
 
}