SphericalGraph.h

Go to the documentation of this file.

// *****************************************************************
// Filename:    AspectGraph.h
// Copyright:   Kai Welke, Chair Prof. Dillmann (IAIM),
//              Institute for Computer Science and Engineering (CSE),
//              University of Karlsruhe. All rights reserved.
// Author:      Kai Welke
// Date:        12.06.2007
// *****************************************************************
 
#pragma once
 
// *****************************************************************
// includes
// *****************************************************************
// stl includes
#include <istream>
#include <ostream>
#include <vector>
 
// local includes
#include "Structs.h"
 
// *****************************************************************
// defines
// *****************************************************************
#define MAX_NODES 100000
 
// *****************************************************************
// nodes and edges
// *****************************************************************
class CSGEdge
{
public:
    // indices of nodes
    int nIndex1;
    int nIndex2;
 
    // indices of faces (needed in triangulation
    int nLeftFace;
    int nRightFace;
};
 
class CSGNode
{
public:
    CSGNode()
    {
    }
 
    CSGNode(TSphereCoord position)
    {
        m_Position = position;
    }
 
    virtual ~CSGNode()
    {
    }
 
    TSphereCoord
    getPosition()
    {
        return m_Position;
    }
 
    void
    setPosition(TSphereCoord position)
    {
        m_Position = position;
    }
 
    int
    getIndex()
    {
        return m_nIndex;
    }
 
    void
    setIndex(int nIndex)
    {
        m_nIndex = nIndex;
    }
 
    virtual CSGNode*
    clone()
    {
        CSGNode* copy = new CSGNode(m_Position);
        copy->setIndex(m_nIndex);
        return copy;
    }
 
protected:
    TSphereCoord m_Position;
    int m_nIndex;
};
 
// *****************************************************************
// types
// *****************************************************************
using TEdgeList = std::vector<CSGEdge*>;
using TNodeList = std::vector<CSGNode*>;
 
// *****************************************************************
// definition of class CSphericalGraph
// *****************************************************************
class CSphericalGraph
{
public:
    ///////////////////////////////
    // construction / destruction
    ///////////////////////////////
    CSphericalGraph();
    CSphericalGraph(const CSphericalGraph& prototype);
 
    virtual ~CSphericalGraph();
 
    virtual CSGNode*
    getNewNode()
    {
        return new CSGNode();
    }
 
    ///////////////////////////////
    // aspect graph manipulation
    ///////////////////////////////
    // clear graph
    void clear();
 
    // add nodes
    int addNode(CSGNode* pNode);
 
    // add edges
    int addEdge(int nIndex1, int nIndex2);
    int addEdge(int nIndex1, int nIndex2, int nLeftFace, int nRightFace);
 
    // node adjacency (usually only required by addEdge)
    void addNodeAdjacency(int nNode, int nAdjacency);
 
    ///////////////////////////////
    // member access
    ///////////////////////////////
    TEdgeList* getEdges();
    TNodeList* getNodes();
 
    CSGEdge* getEdge(int nEdgeIndex);
    CSGNode* getNode(int nIndex);
    std::vector<int>* getNodeAdjacency(int nIndex);
 
    ///////////////////////////////
    // file io
    ///////////////////////////////
    virtual bool read(std::istream& infile);
    virtual bool readNode(std::istream& infile);
    virtual bool readEdge(std::istream& infile);
 
    virtual bool write(std::ostream& outfile);
    virtual bool writeNode(std::ostream& outfile, int n);
    virtual bool writeEdge(std::ostream& outfile, int e);
 
 
    ///////////////////////////////
    // operators
    ///////////////////////////////
    CSphericalGraph& operator=(CSphericalGraph const& rhs);
 
protected:
    TEdgeList m_Edges;
    TNodeList m_Nodes;
    std::vector<int> m_NodeAdjacency[MAX_NODES];
};