PlanarizationLayout.h

Go to the documentation of this file.

/*
 * $Revision: 2027 $
 * 
 * last checkin:
 *   $Author: gutwenger $ 
 *   $Date: 2010-09-01 11:55:17 +0200 (Wed, 01 Sep 2010) $ 
 ***************************************************************/
 
#ifdef _MSC_VER
#pragma once
#endif

#ifndef OGDF_UML_PLANARIZATION_LAYOUT_H
#define OGDF_UML_PLANARIZATION_LAYOUT_H



#include <ogdf/module/UMLLayoutModule.h>
#include <ogdf/module/PlanarSubgraphModule.h>
#include <ogdf/module/EdgeInsertionModule.h>
#include <ogdf/module/LayoutPlanRepModule.h>
#include <ogdf/module/CCLayoutPackModule.h>
#include <ogdf/basic/ModuleOption.h>
#include <ogdf/module/EmbedderModule.h>
#include <ogdf/basic/HashArray.h>



namespace ogdf {


class OGDF_EXPORT PlanarizationLayout : public UMLLayoutModule
{
public:
    PlanarizationLayout();

    // destructor
    virtual ~PlanarizationLayout() { }

    void call(GraphAttributes &GA) {
        doSimpleCall(&GA, 0);
    }

    virtual void call(UMLGraph &umlGraph);

    void simpleCall(UMLGraph &umlGraph) {
        doSimpleCall(&umlGraph, &umlGraph);
    }

    virtual void callSimDraw(UMLGraph &umlGraph);

    virtual void callFixEmbed(UMLGraph &umlGraph);

    //call with information about objects that should be
    //fixed as much as possible in the old/new drawing
    //for incremental drawing: takes a fixed part of the input
    //graph (indicated by fixedNodes(Edges)==true), embeds it using
    //the input layout, then inserts the remaining part into this embedding
    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;
    }

    bool preprocessCliques() const {
        return m_processCliques;
    }

    void preprocessCliques(bool b) {
        m_processCliques = b;
    }

    int minCliqueSize() const {
        return m_cliqueSize;
    }

    void minCliqueSize(int i) {
        m_cliqueSize = max(i, 3);
    }

    //set the option field for the orthogonal layouter
    void setLayouterOptions(int ops)
    {m_planarLayouter.get().setOptions(ops);}

    //draw hierarchy nodes corresponding to their level
    void alignSons(bool b) 
    {
        int opts = m_planarLayouter.get().getOptions();

        if (b) m_planarLayouter.get().setOptions(opts | umlOpAlign); 
        else  m_planarLayouter.get().setOptions(opts & ~umlOpAlign);
    }


    void setSubgraph(PlanarSubgraphModule *pSubgraph) {
        m_subgraph.set(pSubgraph);
    }

    void setInserter(EdgeInsertionModule *pInserter) {
        m_inserter.set(pInserter);
    }

    void setEmbedder(EmbedderModule *pEmbedder) {
        m_embedder.set(pEmbedder);
    }

    void setPlanarLayouter(LayoutPlanRepModule *pPlanarLayouter) {
        m_planarLayouter.set(pPlanarLayouter);
    }

    void setPacker(CCLayoutPackModule *pPacker) {
        m_packer.set(pPacker);
    }


    int numberOfCrossings() const {
        return m_nCrossings;
    }

    void assureDrawability(UMLGraph& umlGraph);


protected:
    void doSimpleCall(GraphAttributes *pGA, UMLGraph *pUmlGraph);

    //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

    //collect and store nodes around center in correct order
    void fillAdjNodes(List<node>& adjNodes, PlanRepUML& PG, node centerNode, 
        NodeArray<bool>& isClique, Layout& drawing);

    void arrangeCCs(PlanRep &PG, GraphAttributes &GA, Array<DPoint> &boundingBox);

private:
    ModuleOption<PlanarSubgraphModule> m_subgraph;

    ModuleOption<EdgeInsertionModule>  m_inserter;

    ModuleOption<EmbedderModule>       m_embedder;

    ModuleOption<LayoutPlanRepModule>  m_planarLayouter;

    ModuleOption<CCLayoutPackModule>   m_packer;

    double m_pageRatio;    
    int m_nCrossings;      
    bool m_arrangeLabels;  
    bool m_processCliques; 
    int m_cliqueSize;      

    // temporary changes to avoid errors
    List<edge> m_fakedGens; // made to associations
    bool m_fakeTree;

    face findBestExternalFace(
        const PlanRep &PG,
        const CombinatorialEmbedding &E);
};


//--------------------------------------------------------
//incremental part

class AddNodeComparer
{
    HashArray<int, int> *m_indToDeg;

public:
    AddNodeComparer(HashArray<int, int> &ha) : m_indToDeg(&ha) { }

    int compare(const node &v1, const node &v2) const {
        if ((*m_indToDeg)[v1->index()] < (*m_indToDeg)[v2->index()])
            return 1;
        else if ((*m_indToDeg)[v1->index()] > (*m_indToDeg)[v2->index()])
            return -1;
        else
            return 0;
    }
    
    OGDF_AUGMENT_COMPARER(node)
};


} // end namespace ogdf


#endif