Roadmap.h

#ifndef ROADMAP_H
#define ROADMAP_H

#include "ConMath.h"
#include <vector>
#include <string>


#include "path.h"

#include "config.h"
#include "entity.h"

/*
  The Roadmap is a set of 3D paths (edges) that intersect at nodes. Thus it has a representation
  as an undirected graph with the lengths of the paths as the weight of the edges. In order to avoid
  copying unnecessary 3D data, a subspace is a subset of the Roadmap, but in a discrete representation.
*/

class Roadmap : public Entity{
public:
  typedef enum{
        NO_ACCESS,
        INVALID_ID,
        NO_NODE
  } Error;

  Roadmap(const ConStruct& con);
  Roadmap() : edges(0), nodes(0), discrete(0) {};
  virtual ~Roadmap();

  /*
    Different roadmaps (GVG, vertex graph) can determine criteria
        for passable subspaces by overriding the member function.
  */
  virtual DiscreteGraph PassableSubspace() const;

  virtual Path GeneratePath(const Vector &start, const Vector &goal, const DiscreteGraph& subspace) const;

  //returns the edge's index and a point on the edge to access
  virtual Path::Point Access(const Vector& pos, int &edge, const DiscreteGraph& subspace) const;

  //returns the id of the node at the specifed position
  //throws NO_NODE if the position is not "close" to a node
  int GetNodeID(const Vector& position) const;

  //given the id of a node returns the ids of edges that connect to it
  std::vector<int> GetAdjoiningEdges(const int node_id) const;

  //returns Path representation of edge given the edge id
  const Path& GetEdge(const int edge_id) const;

  //adds edge to the roadmap (linking to it based on endpts) and returns new edge id
  int AddEdge(const Path& p);

  void RemoveEdge(const int edge_id);

  virtual void Render (void)=0;

protected:

  class Edge : public Path {
  public:
        Edge(const ConStruct& con);
        Edge();
        int getBeginNode() const { return begin_node; };
        int getEndNode() const { return end_node; };
        bool isForward(const int begin, const int end) const;
        Edge& operator =(const Edge& e);

  protected:
        int begin_node, end_node;
  };

  struct NodeInfo{
        int target;
        int edge;
        bool forward;
  };

  class Node{
  public:
        Node(const int initid, const Vector &pos);
        Node(const Node &in);
        Node();
        ~Node();

        void Link(const NodeInfo& info);
        NodeInfo getNeighborbyID(const int request) const;
        NodeInfo getNeighbor(const int index) const;
        int getNeighborCount() const;

        Node& operator =(const Node& n);

  protected:
        int id;
        std::vector<NodeInfo> neighbors;
        Vector coords;
  };
  friend class Node;

  std::vector<Edge> edges;
  std::vector<Node> nodes;
  DiscreteGraph discrete;
  private:
};

#endif

---