graphupdater.hpp

#ifndef GRAPHUPDATER_HPP
#define GRAPHUPDATER_HPP

#include "API/Roadmap/node.hpp"
#include "API/Roadmap/edge.hpp"
#include "API/Trajectory/trajectory.hpp"
#include "API/Roadmap/graph.hpp"
#include <vector>
#include <set>

using namespace std;
using namespace API;

class GraphUpdater
{
public:
  
        //contructors and destructor
        GraphUpdater(Graph * graph);

        double reduction(unsigned int param);

        bool connexity(unsigned int param);
        bool coverage(unsigned int param);

    bool correction(unsigned int param, double timelimit = -1);
    bool correction(Node* from, unsigned int param, double timelimit = -1);
    bool correction(confPtr_t from, unsigned int param, double timelimit = -1);

    vector<vector<Node*> > getAvailableTrajectories(confPtr_t from, bool computeNew = false);
    vector<vector<Node*> > getAvailableTrajectories(Node* from, bool computeNew = false);

    Trajectory* getBestTrajectory(confPtr_t from, bool updateEnv = true);
    Trajectory* getBestTrajectory(Node* from, bool updateEnv = true);

    vector<Trajectory*> getTrajectories();

    void setCurrentTrajectory(Trajectory* trajectory);
    Trajectory* getCurrentTrajectory();

    void setCurrentConfiguration(confPtr_t configuration);
    Node* getPrevNode();
    Node* getNextNode();

private:
        Graph* graph;
        Node* start;
        Node* goal;

    Trajectory* currentTrajectory;
    confPtr_t currentConfiguration;
    Node* prevNode;
    Node* nextNode;

    vector< vector<Node*> > trajectories;

        void updateTrajectories();
        vector<Node*> getChildrenOf(Graph* graph, vector<Node*> nodes);
    vector<Node*> getParentOf(Graph* graph, vector<Node*> nodes);
    unsigned int connectNodes(vector<Node*> nodes);
};

extern GraphUpdater* API_activeGraphUpdater;

#endif