HypergraphLayout.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Array.h>
#include <ogdf/basic/Graph.h>
#include <ogdf/basic/basic.h>
#include <ogdf/basic/geometry.h>
#include <ogdf/hypergraph/HypergraphLayoutModule.h>
#include <ogdf/planarity/CrossingMinimizationModule.h>
#include <ogdf/planarity/EmbedderModule.h>
#include <ogdf/planarity/LayoutPlanRepModule.h>
 
#include <memory>
 
namespace ogdf {
class GraphCopySimple;
class HypergraphAttributes;
class HypergraphAttributesES;
class PlanRep;
template<class E>
class List;
 
class OGDF_EXPORT HypergraphLayoutES : public HypergraphLayoutModule {
public:
    enum class Profile { Normal = 0x000001, ElectricCircuit = 0x000002 };
 
private:
    double m_ratio;
 
    int m_crossings;
 
    bool m_constraintIO;
 
    // TODO: This might require some tweaks in Hypergraph class.
    bool m_constraintPorts;
 
    Profile m_profile;
 
    std::unique_ptr<LayoutPlanRepModule> m_planarLayoutModule;
 
    std::unique_ptr<CrossingMinimizationModule> m_crossingMinimizationModule;
 
    std::unique_ptr<EmbedderModule> m_embeddingModule;
 
public:
    // constructor
    HypergraphLayoutES();
 
    // destructor
    virtual ~HypergraphLayoutES() { }
 
    // Dynamic casting is currently not working as desired and hence we left
    // the following call inherited from superclass empty.
    virtual void call(HypergraphAttributes& HA) override;
 
#if 0
    void call(HypergraphAttributesES &HA);
#endif
 
    HypergraphLayoutES& operator=(const HypergraphLayoutES& hl);
 
    int crossings() const { return m_crossings; }
 
    double ratio() const { return m_ratio; }
 
    void setConstraintIO(bool pConstraintIO) { m_constraintIO = pConstraintIO; }
 
    void setProfile(Profile pProfile) { m_profile = pProfile; }
 
    void setPlanarLayoutModule(LayoutPlanRepModule* pPlanarLayoutModule) {
        m_planarLayoutModule.reset(pPlanarLayoutModule);
    }
 
    void setCrossingMinimizationModule(CrossingMinimizationModule* pCrossingMinimizationModule) {
        m_crossingMinimizationModule.reset(pCrossingMinimizationModule);
    }
 
    void setEmbeddingModule(EmbedderModule* pEmbeddingModule) {
        m_embeddingModule.reset(pEmbeddingModule);
    }
 
 
private:
    void layout(HypergraphAttributesES& pHA);
 
#if 0
    void planarizeCC(PlanRep &ccPlanarRep, List<edge> &fixedShell);
#endif
 
    void packAllCC(const PlanRep& planarRep, const GraphCopySimple& gc, HypergraphAttributesES& pHA,
            Array<DPoint>& bounding);
 
    void insertShell(GraphCopySimple& planarRep, List<node>& src, List<node>& tgt,
            List<edge>& fixedShell);
 
    void removeShell(PlanRep& planarRep, NodePair& st);
 
    void applyProfile(HypergraphAttributesES& HA);
};
 
}