PlanarizationLayoutUML.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Array.h>
#include <ogdf/basic/CombinatorialEmbedding.h>
#include <ogdf/basic/Graph.h>
#include <ogdf/basic/GraphAttributes.h>
#include <ogdf/basic/HashArray.h>
#include <ogdf/basic/List.h>
#include <ogdf/basic/basic.h>
#include <ogdf/basic/geometry.h>
#include <ogdf/orthogonal/OrthoRep.h>
#include <ogdf/packing/CCLayoutPackModule.h>
#include <ogdf/planarity/EmbedderModule.h>
#include <ogdf/uml/LayoutPlanRepUMLModule.h>
#include <ogdf/uml/UMLCrossingMinimizationModule.h>
#include <ogdf/uml/UMLGraph.h>
#include <ogdf/uml/UMLLayoutModule.h>
 
#include <memory>
 
namespace ogdf {
class PlanRep;
class PlanRepUML;
 
class OGDF_EXPORT PlanarizationLayoutUML : public UMLLayoutModule {
public:
    PlanarizationLayoutUML();
 
    // destructor
    virtual ~PlanarizationLayoutUML() { }
 
    void call(GraphAttributes& GA) { doSimpleCall(GA); }
 
    virtual void call(UMLGraph& umlGraph) override;
 
    void simpleCall(UMLGraph& umlGraph) {
        //this simple call method does not care about any special treatments
        //of subgraphs, layout informations etc., therefore we save the
        //option status and set them back later on
#if 0
        //cliques are only handled for UMLGraphs, so it is save to
        //only set this value here and not in the GraphAttributes interface method.
        bool l_saveCliqueHandling = m_processCliques;
        m_processCliques = false;
#endif
 
        // preprocessing: insert a merger for generalizations
 
        preProcess(umlGraph);
        umlGraph.insertGenMergers();
 
        doSimpleCall(umlGraph);
 
        umlGraph.undoGenMergers();
 
        umlGraph.removeUnnecessaryBendsHV();
 
        postProcess(umlGraph);
 
#if 0
        m_processCliques = l_saveCliqueHandling;
#endif
    }
 
    void simpleCall(GraphAttributes& GA) {
        doSimpleCall(GA);
        GA.removeUnnecessaryBendsHV();
    }
 
#if 0
    virtual void callSimDraw(UMLGraph &umlGraph);
 
    **
     * \brief Calls planarization layout with fixed embedding given by \p umlGraph.
     * \pre The graph has no self-loops.
     * @param umlGraph is the input graph and will also be assigned the layout information.
     *        The fixed embedding is obtained from the layout information (node
     *        coordinates, bend points) in \p umlGraph.
     */
    virtual void callFixEmbed(UMLGraph &umlGraph);
#endif
 
 
    virtual void callIncremental(UMLGraph& umlgraph, NodeArray<bool>& fixedNodes,
            const EdgeArray<bool>& fixedEdges);
 
    double pageRatio() const { return m_pageRatio; }
 
    void pageRatio(double ratio) { m_pageRatio = ratio; }
 
    //set the option field for the planar layouter
    void setLayouterOptions(int ops) { m_planarLayouter->setOptions(ops); }
 
    //draw hierarchy nodes corresponding to their level
    void alignSons(bool b) {
        int opts = m_planarLayouter->getOptions();
 
        if (b) {
            m_planarLayouter->setOptions(opts | UMLOpt::OpAlign);
        } else {
            m_planarLayouter->setOptions(opts & ~UMLOpt::OpAlign);
        }
    }
 
    void setCrossMin(UMLCrossingMinimizationModule* pCrossMin) { m_crossMin.reset(pCrossMin); }
 
    void setEmbedder(EmbedderModule* pEmbedder) { m_embedder.reset(pEmbedder); }
 
    void setPlanarLayouter(LayoutPlanRepUMLModule* pPlanarLayouter) {
        m_planarLayouter.reset(pPlanarLayouter);
    }
 
    void setPacker(CCLayoutPackModule* pPacker) { m_packer.reset(pPacker); }
 
    int numberOfCrossings() const { return m_nCrossings; }
 
    void assureDrawability(UMLGraph& umlGraph);
 
 
protected:
    void doSimpleCall(GraphAttributes& GA);
 
    //sorts the additional nodes for piecewise insertion
    void sortIncrementalNodes(List<node>& addNodes, const NodeArray<bool>& fixedNodes);
    void getFixationDistance(node startNode, HashArray<int, int>& distance,
            const NodeArray<bool>& fixedNodes);
    //reembeds already planarized PG in case of errors
    void reembed(PlanRepUML& PG, int ccNumber, bool l_align = false, bool l_gensExist = false);
 
    virtual void preProcess(UMLGraph& UG);
    virtual void postProcess(UMLGraph& UG); //redo changes at original
 
    void arrangeCCs(PlanRep& PG, GraphAttributes& GA, Array<DPoint>& boundingBox);
 
private:
    face findBestExternalFace(const PlanRep& PG, const CombinatorialEmbedding& E);
 
    std::unique_ptr<UMLCrossingMinimizationModule> m_crossMin;
 
    std::unique_ptr<EmbedderModule> m_embedder;
 
    std::unique_ptr<LayoutPlanRepUMLModule> m_planarLayouter;
 
    std::unique_ptr<CCLayoutPackModule> m_packer;
 
    double m_pageRatio; 
    int m_nCrossings; 
    bool m_arrangeLabels; 
 
    // temporary changes to avoid errors
    List<edge> m_fakedGens; // made to associations
    bool m_fakeTree;
};
 
}