Graph.h

Go to the documentation of this file.

//
//  VBOVertex.h
//  GlobeEngine
//
//  Created by Mathias Thöny on 27.12.11.
//  Copyright (c) 2011 University of Zurich. All rights reserved.
//

#ifndef GlobeEngine_Graph_h
#define GlobeEngine_Graph_h

#include "VBOVertex.h"
#include "OpenGL_Includes.h"
#include <map>
#include <iostream>
#include "GraphNode.h"

namespace geGraph {
    /*
     * common graph with edges and nodes
     */
    template <class NODETYPE, class EDGETYPE, class U> class Graph
    {
    public:
        Graph(){
            clearProperties();
        }
        ~Graph() {}
        
        void clearProperties() {
            numberOfConnectors = 0;
            numberOfAbandonedNodes = 0;
        }
        
        unsigned int addNode(NODETYPE _node){
            unsigned int idx = nodes.size();
            nodes.push_back(GraphNode< U >(idx));
            std::pair< NODETYPE, U> pairContent(_node, idx);
            nodeByContent.insert(pairContent);
            std::pair< U, NODETYPE> pairID( idx, _node);
            nodeByID.insert(pairID);
            return idx;
        }
        
        const std::map< U, NODETYPE > getMapToIterate() const {
            return this->nodeByID;
        }
        
        U getNodeCount() const {
            return this->nodes.size();
        }
        
        U getNodeIDByContent(const NODETYPE _content) const {
            typename std::map< NODETYPE, U >::const_iterator nodeByContentItr = nodeByContent.find(_content);
            if(nodeByContentItr != nodeByContent.end()) {
                return nodeByContentItr->second;
            }else{
                return 0;
            }
        }
        
        NODETYPE getNodeContentByID(U _id) const {
            typename std::map< U, NODETYPE >::const_iterator nodeByIDItr = nodeByID.find(_id);
            if(nodeByIDItr != nodeByID.end()) {
                return nodeByIDItr->second;
            }
            
            return NODETYPE();
        }
        
        std::vector< GraphNode< U > > getGraphNodes(){
            return nodes;
        }
        
        std::vector< U > getEndnodeIDs(){
            std::vector< U > ids;
            for (int i = 0;i < nodes.size();i++) {
                if (nodes[i].isEndpoint()) {
                    ids.push_back(nodes[i].getUID());
                }
            }
            return ids;
        }
        
        std::vector< U > getCrossingIDs(){
            std::vector< U > ids;
            for (int i = 0;i < nodes.size();i++) {
                if (nodes[i].isCrossing()) {
                    ids.push_back(nodes[i].getUID());
                }
            }
            return ids;
        }
        
        void updateGraphProperties() {
            this->clearProperties();
            for (int i = 0;i < nodes.size();i++) {
                if (nodes[i].isEndpoint()) {
                    this->endPoints.push_back(i);
                }
                if (nodes[i].isCrossing()) {
                    this->crossings.push_back(i);
                }
                if (nodes[i].isConnector()) {
                    numberOfConnectors++;
                }
                if (!nodes[i].hasNeighbors()) {
                    numberOfAbandonedNodes++;
                }
            }
        }
        
        unsigned int getNumberOfEndpoints() const {
            return this->endPoints.size();
        }
        
        unsigned int getNumberOfCrossings() const {
            return this->crossings.size(); 
        }
        
        U getEndPointID(unsigned int _idx){
            return this->endPoints[_idx];
        }
        
        U getCrossingID(unsigned int _idx){
            return this->crossings[_idx];
        }
        
        U getEdgeCount(){
            return this->edges.size();
        }
        
        EDGETYPE* getEdge(unsigned int _idx){
            return &this->edges[_idx];
        }
        
        GraphNode< U > getNode(unsigned int _idx){
            return this->nodes[_idx];
        }
        
    protected:
        std::map< NODETYPE, U > nodeByContent;
        std::map< U, NODETYPE > nodeByID;
        
        std::vector< GraphNode< U > > nodes;
        
        std::vector< EDGETYPE > edges;
        std::map< std::pair < U , U >, U > forwardEdges;
        std::map< std::pair < U , U >, U > backwardEdges;
        
        std::vector< U > endPoints;
        std::vector< U > crossings;
        
        // graph properties
        unsigned int numberOfConnectors;
        unsigned int numberOfAbandonedNodes;
    };
    
}
#endif