ClustererModule.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Graph.h>
#include <ogdf/basic/GraphList.h>
#include <ogdf/basic/SList.h>
#include <ogdf/basic/basic.h>
#include <ogdf/basic/memory.h>
#include <ogdf/basic/simple_graph_alg.h>
 
namespace ogdf {
class ClusterGraph;
 
//Helper classes to code a clustering, used as an interface to applications that
//need to build the clustergraph structure themselves
class SimpleCluster {
public:
    SimpleCluster(SimpleCluster* parent = nullptr) : m_size(0), m_parent(parent), m_index(-1) { }
 
    //insert vertices and children
    void pushBackVertex(node v) { m_nodes.pushBack(v); }
 
    void pushBackChild(SimpleCluster* s) { m_children.pushBack(s); }
 
    void setParent(SimpleCluster* parent) { m_parent = parent; }
 
    SimpleCluster* getParent() { return m_parent; }
 
    void setIndex(int index) { m_index = index; }
 
    int getIndex() { return m_index; }
 
    SList<node>& nodes() { return m_nodes; }
 
    SList<SimpleCluster*>& children() { return m_children; }
 
    int m_size; //preliminary: allowed to be inconsistent with real vertex number to
    //allow lazy vertex addition (should therefore be local Array?)
 
private:
    SList<node> m_nodes;
    SList<SimpleCluster*> m_children;
    SimpleCluster* m_parent;
    int m_index; //index of the constructed cluster
};
 
class OGDF_EXPORT ClustererModule {
public:
    //Constructor taking a graph G to be clustered
    explicit ClustererModule(const Graph& G) : m_pGraph(&G) { OGDF_ASSERT(isConnected(G)); }
 
    // Allows to cluster multiple
    // graphs with the same instance of the Clusterer
    ClustererModule() { }
 
    void setGraph(const Graph& G) {
        OGDF_ASSERT(isConnected(G));
        m_pGraph = &G;
    }
 
    const Graph& getGraph() const { return *m_pGraph; }
 
    virtual void computeClustering(SList<SimpleCluster*>& sl) = 0;
 
    virtual void createClusterGraph(ClusterGraph& C) = 0;
 
    virtual double computeCIndex(const Graph& G, node v) = 0;
 
    virtual double computeCIndex(node v) = 0;
 
    virtual double averageCIndex() { return averageCIndex(*m_pGraph); }
 
    virtual double averageCIndex(const Graph& G) {
        double ciSum = 0.0;
        for (node v : G.nodes) {
            ciSum += computeCIndex(G, v);
        }
        return ciSum / (G.numberOfNodes());
    }
 
protected:
    const Graph* m_pGraph; //the graph to be clustered
 
    OGDF_MALLOC_NEW_DELETE
};
 
}