SubgraphPlanarizer.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Logger.h>
#include <ogdf/planarity/CrossingMinimizationModule.h>
#include <ogdf/planarity/EdgeInsertionModule.h>
#include <ogdf/planarity/PlanarSubgraphModule.h>
 
#include <memory>
#include <random>
 
namespace ogdf {
 
 
class OGDF_EXPORT SubgraphPlanarizer : public CrossingMinimizationModule, public Logger {
    class ThreadMaster;
    class Worker;
 
protected:
    virtual ReturnType doCall(PlanRep& pr, int cc, const EdgeArray<int>* pCostOrig,
            const EdgeArray<bool>* pForbiddenOrig, const EdgeArray<uint32_t>* pEdgeSubGraphs,
            int& crossingNumber) override;
 
public:
    SubgraphPlanarizer();
 
    SubgraphPlanarizer(const SubgraphPlanarizer& planarizer);
 
    virtual CrossingMinimizationModule* clone() const override;
 
    SubgraphPlanarizer& operator=(const SubgraphPlanarizer& planarizer);
 
    void setSubgraph(PlanarSubgraphModule<int>* pSubgraph) { m_subgraph.reset(pSubgraph); }
 
    void setInserter(EdgeInsertionModule* 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, EdgeInsertionModule& inserter,
            std::minstd_rand& rng);
 
    static bool doSinglePermutation(PlanRepLight& prl, int cc, const EdgeArray<int>* pCost,
            const EdgeArray<bool>* pForbid, const EdgeArray<uint32_t>* pEdgeSubGraphs,
            Array<edge>& deletedEdges, EdgeInsertionModule& inserter, std::minstd_rand& rng,
            int& crossingNumber);
 
    std::unique_ptr<PlanarSubgraphModule<int>> m_subgraph; 
    std::unique_ptr<EdgeInsertionModule> m_inserter; 
 
    int m_permutations; 
    bool m_setTimeout; 
    unsigned int m_maxThreads; 
};
 
}