SubgraphPlanarizerUML.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Array.h>
#include <ogdf/basic/Graph.h>
#include <ogdf/basic/Logger.h>
#include <ogdf/basic/basic.h>
#include <ogdf/planarity/PlanarSubgraphModule.h>
#include <ogdf/uml/UMLCrossingMinimizationModule.h>
#include <ogdf/uml/UMLEdgeInsertionModule.h>
 
#include <memory>
#include <random>
 
namespace ogdf {
class PlanRepLight;
class PlanRepUML;
 
 
class OGDF_EXPORT SubgraphPlanarizerUML : public UMLCrossingMinimizationModule, public Logger {
    class ThreadMaster;
    class Worker;
 
protected:
    virtual ReturnType doCall(PlanRepUML& pr, int cc, const EdgeArray<int>* pCostOrig,
            int& crossingNumber) override;
 
public:
    SubgraphPlanarizerUML();
 
    SubgraphPlanarizerUML(const SubgraphPlanarizerUML& planarizer);
 
    virtual UMLCrossingMinimizationModule* clone() const override;
 
    SubgraphPlanarizerUML& operator=(const SubgraphPlanarizerUML& planarizer);
 
    void setSubgraph(PlanarSubgraphModule<int>* pSubgraph) { m_subgraph.reset(pSubgraph); }
 
    void setInserter(UMLEdgeInsertionModule* pInserter) { m_inserter.reset(pInserter); }
 
    int permutations() { return m_permutations; }
 
    void permutations(int p) { m_permutations = p; }
 
    bool setTimeout() { return m_setTimeout; }
 
    void setTimeout(bool b) { m_setTimeout = b; }
 
    unsigned int maxThreads() const { return m_maxThreads; }
 
    void maxThreads(unsigned int n) {
#ifndef OGDF_MEMORY_POOL_NTS
        m_maxThreads = n;
#endif
    }
 
private:
    static void doWorkHelper(ThreadMaster& master, UMLEdgeInsertionModule& inserter,
            std::minstd_rand& rng);
 
    static bool doSinglePermutation(PlanRepLight& prl, int cc, const EdgeArray<int>* pCost,
            Array<edge>& deletedEdges, UMLEdgeInsertionModule& inserter, std::minstd_rand& rng,
            int& crossingNumber);
 
    std::unique_ptr<PlanarSubgraphModule<int>> m_subgraph; 
    std::unique_ptr<UMLEdgeInsertionModule> m_inserter; 
 
    int m_permutations; 
    bool m_setTimeout; 
    unsigned int m_maxThreads; 
};
 
}