ClustererModule.h

Go to the documentation of this file.

/*
 * $Revision: 2299 $
 * 
 * last checkin:
 *   $Author: gutwenger $ 
 *   $Date: 2012-05-07 15:57:08 +0200 (Mon, 07 May 2012) $ 
 ***************************************************************/
 
#ifdef _MSC_VER
#pragma once
#endif

#ifndef OGDF_CLUSTERER_MODULE_H
#define OGDF_CLUSTERER_MODULE_H

#include <ogdf/basic/Graph.h>
#include <ogdf/cluster/ClusterGraph.h>
#include <ogdf/basic/simple_graph_alg.h>


#include <iostream>

namespace ogdf {
    
    //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 = 0) : 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 SimpleCluster
    
    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) 
        {
            node v;
            double ciSum = 0.0;
            forall_nodes(v, G)
            {
                ciSum += computeCIndex(G, v);
            }
            return ciSum / (G.numberOfNodes());
        }
        
        
        protected:
        const Graph* m_pGraph; //the graph to be clustered
          
        OGDF_MALLOC_NEW_DELETE
        
    };//class ClustererModule
    
    
    
} //end namespace ogdf


#endif /*CLUSTERERMODULE_H_*/