Network.h

// Network.h: interface for the Network class.
//

#if !defined(AFX_NETWORK_H__751BFE9D_1DCC_44AD_A59F_CF1F4D1EB378__INCLUDED_)
#define AFX_NETWORK_H__751BFE9D_1DCC_44AD_A59F_CF1F4D1EB378__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "entity.h"
#include "path.h"
//A Network is a collection of Paths that intersect at Nodes
//these paths are known as Edges
//Network assumes that all Edges are entirely traced

/*
  Network aims to be context independent; that is, it is intended to be the storage backbone
  for things like:
  --Coverage traces
  --HGVG and company
  --whatever other roadmap comes up in the future
*/
class Network : public Entity{
public:

  class Node{
  public:
    Node(const Vector& inpos);
    Node(const ConStruct& context);
    ~Node(){};

    void AddEdge(const int index)
      {edges.push_back(index);};

    void RemoveEdge(const int edge_index);

    int EdgeIndex(const int index) const
      {return edges[index];};

    int NumEdges() const
      {return edges.size();};

    //archive the node in a ConStruct
    ConStruct ToConStruct() const;

    const Vector& GetPosition() const {return pos;};
  private:
    std::vector<int> edges;
    Vector pos;
  };

  Network(const ConStruct& con);
  Network(const ConStruct& con, const PathFactory& path_factory);
  ~Network();

  //provides functionality for path planning only on the Network
  //the Network can only plan Paths between Points on the same connected set
  //for planning paths between points in the entire workspace,
  //use the derived class Roadmap
  Path Plan(const Vector& start, const Vector& goal) const;

  //add an Edge to the Network;
  //the Network automatically figures out if Edge is connected to current Network
  //or adds new Nodes if Edge has endpoints not on the current Network
  //if client is not sure that the endpoints don't exist in the node, pass in NO_NODE
  //if an Edge connects to the Network at a point other than a Node, a new Node is
  //created and the intersected Edge is split accordingly
  void AddEdge(const Path& p, const int begin_node, const int end_node);


  void AddCycleEdge(const Path& p);

  bool HasEdge(const int node1, const int node2) const;
  static const int NO_NODE;
  //retrieve Node index number; if there is no match on the given position, NO_NODE is returned
  int MatchNode(const Vector& pos) const;
  
  //retrieve Node by index number
  Node& GetNode(const int index);

  //archive this class in a ConStruct
  ConStruct ToConStruct() const;

  //render using OpenGL
  void Render() const;

  //an Edge is the connection between two nodes
  struct Edge{
    Edge(const Path& ip, const int begin, const int end) : p(ip), begin_index(begin), end_index(end){};
    Edge(const ConStruct& con) : p(con.Struct("path")),
      begin_index(con.Int("begin_index", NO_NODE)), end_index(con.Int("end_index", NO_NODE)){}
    Path p;         //path data between nodes
    int begin_index;  //node at p.Point(Path::BEGIN)
    int end_index;  //node at p.Point(Path::END)
  };
  int NumEdges() const{ return edges.size();};
  const Edge& GetEdge(const int index) const { return edges[index];};
  
private:
  std::vector<Edge> edges;
  std::vector<Node> nodes;

  const double node_match_threshold; //matching threshold between an arbitrary point and Node position
                                     //used when adding Edges or referring to a Node by position

  int AddEdgeHelper(const int node, const int new_edge, const Vector& pt);
};

#endif // !defined(AFX_NETWORK_H__751BFE9D_1DCC_44AD_A59F_CF1F4D1EB378__INCLUDED_)

---