attentive.h

#ifndef ATTENTIVE_H
#define ATTENTIVE_H
#include "configurator.h"
 
class AttentiveConfigurator:public virtual Configurator{
    protected:
    StateMatcher matcher;
ExecutionInfo package_info(vertexDescriptor gv=TransitionSystem::null_vertex(), bool been=false){
    return ExecutionInfo(currentVertex, gv, currentTask, controlGoal, been, m_plan);
}
 
virtual Disturbance getDisturbance(TransitionSystem&g, vertexDescriptor v, b2World & world, const Direction & dir, const b2Transform& start);
 
virtual void backtrack(std::vector <vertexDescriptor>& evaluation_q, std::vector <vertexDescriptor>&priority_q, std::set<vertexDescriptor>& closed, std::vector <vertexDescriptor>& plan_prov, vertexDescriptor module_src=MOVING_VERTEX, vertexDescriptor startRecycle=MOVING_VERTEX);
 
virtual std::vector <vertexDescriptor> splitTask(vertexDescriptor v, Direction d, vertexDescriptor src=TransitionSystem::null_vertex());
 
virtual bool propagateD(vertexDescriptor v1, vertexDescriptor v0, std::set<vertexDescriptor>*closed=NULL, StateMatcher::MATCH_TYPE match=StateMatcher::_FALSE);
 
//if in plan the vertex gets priority
void planPriority(TransitionSystem&, vertexDescriptor); 
 
 
//adjust real-world task
void adjust_rw_task(const vertexDescriptor&, TransitionSystem &, Task*, const b2Transform &);
 
virtual VertexMatch findMatch(State s, Direction dir=Direction::UNDEFINED, StateMatcher::MATCH_TYPE match_type=StateMatcher::_TRUE, StateDifference * _sd=NULL, std::vector <VertexMatch>*other_matches=NULL); //matches to most likely
 
virtual std::vector<vertexDescriptor> explorer(vertexDescriptor v, TransitionSystem&g, b2World &w); //evaluates only after DEFAULT, internal one step lookahead
 
void resetPhi();
 
std::pair <edgeDescriptor, bool> add_vertex_now(const vertexDescriptor & src, vertexDescriptor & v1, Disturbance obs,Edge edge=Edge(), bool topDown=0);
 
std::pair <edgeDescriptor, bool> add_vertex_retro(vertexDescriptor &src, vertexDescriptor &v1, Edge edge=Edge(), bool topDown=0);
 
std::vector <Direction> getExploredDirections(vertexDescriptor v, const std::vector<Direction>& directions);
 
virtual void removeExploredTransitions(vertexDescriptor v);
 
virtual void transitionMatrix(vertexDescriptor v, Direction d, vertexDescriptor src); 
 
void applyTransitionMatrix(vertexDescriptor v0, Direction d, bool ended, vertexDescriptor src, std::vector<vertexDescriptor>& plan_prov);
 
void addToPriorityQueue(vertexDescriptor v, std::vector<vertexDescriptor>& queue, const std::set <vertexDescriptor>& closed);
 
 
//removes singleton vertices and self-edges
void ts_cleanup();
 
//apply affine transformation to states (e.g. if the same situation encountered in the past is reencountered)
void shift_states(TransitionSystem &, const std::vector<vertexDescriptor>&, const b2Transform &); //shifts a sequence of states by a certain transform
 
//return vertex from which exploration of the environment starts (explorer)
vertexDescriptor get_explore_start(TransitionSystem &);
 
void pre_explore();
 
 
//std::vector <State> output_plan(const std::vector<vertexDescriptor> &, const TransitionSystem &);
 
void explore_plan(b2World&)override;
 
std::vector<Direction>::iterator  get_next_option(vertexDescriptor v, vertexDescriptor src, std::vector<vertexDescriptor> full_plan);
 
virtual bool recycle_plan(vertexDescriptor v, vertexDescriptor &v0, vertexDescriptor & task_start, StateMatcher::MATCH_TYPE &matchType, 
                b2Transform & shift_start, b2Transform& sk_first_start, std::pair<edgeDescriptor, bool>&edge,
                std::vector<vertexDescriptor> &plan_prov, Direction t_get_direction);
 
 
std::pair<State, Edge> simulation_setup(b2World& w, Task & t, vertexDescriptor v0, b2Transform shift, b2Transform &start, std::vector<Direction>v0_options);
 
void reassign_direction(vertexDescriptor bestNext, Direction& direction);
 
bool matchToSafe(VertexMatch &match,const std::vector<VertexMatch> &other_matches=std::vector<VertexMatch>());
 
std::pair<edgeDescriptor, bool> setup_match_edge(VertexMatch &match, vertexDescriptor &v0, vertexDescriptor & v1,const Edge& k, Direction direction, bool changedMatch);
 
virtual std::vector <vertexDescriptor> task_vertices(vertexDescriptor v, std::pair<bool, edgeDescriptor>* ep=NULL);
 
// /**
//  * @brief Returns a visited edge if present, or if the current 
//  * 
//  * @param es 
//  * @param g 
//  * @param cv 
//  * @return std::vector <vertexDescriptor> 
//  */
// std::vector <vertexDescriptor> visitedOrVisitingEdge(const std::vector <edgeDescriptor>& es, TransitionSystem& g, vertexDescriptor cv=TransitionSystem::null_vertex());
 
vertexDescriptor getRecyclingStart(vertexDescriptor v, vertexDescriptor v1, vertexDescriptor taskStart);
 
std::vector <edgeDescriptor> inEdges(vertexDescriptor v, Direction d = UNDEFINED); //returns a vector containing all the in-edges of a vertex which have the specified direction
 
virtual bool closeVertex(std::set<vertexDescriptor> & closed, vertexDescriptor v);
 
std::pair<edgeDescriptor, bool> addEdgeRetrospectively(vertexDescriptor v, vertexDescriptor &v1, const State & s_tmp,std::pair<edgeDescriptor, bool> first_edge, Direction d, float linearSpeed);
 
void correctQueue(std::vector<vertexDescriptor>& queue, vertexDescriptor v, vertexDescriptor startRecycle, int planProvSize);
 
void adjustProbability(const edgeDescriptor &e);
 
void abandonPlan(std::vector<vertexDescriptor>& planProv, vertexDescriptor v0, vertexDescriptor v1);
 
virtual std::vector<Direction> partiallyExplorativeOptions(std::pair<bool, edgeDescriptor> ve);
 
virtual Robot makeRobot(b2World & w, const b2Transform & start);
class EvaluationQueueManager{
    protected:
    vertexDescriptor lastAdded=TransitionSystem::null_vertex(); //last vertex added to the evaluation queue
    public:
 
    void addToEvaluationQueue(std::vector <vertexDescriptor>& evaluationQueue, vertexDescriptor v1, TransitionSystem & g, vertexDescriptor v);
 
    void reset(vertexDescriptor v=TransitionSystem::null_vertex()){
        lastAdded=v;
    }
};
 
void visitedDirectionsPushBack( vertexDescriptor v, std::vector<Direction> & visitedDirections, Direction direction);
 
virtual StateMatcher::MATCH_TYPE desiredMatch() {
    return StateMatcher::MATCH_TYPE::ABSTRACT;
}
 
void enforce_edge();
 
virtual bool shouldPartiallyExplore(const std::vector<edgeDescriptor>& oe, std::pair<bool, edgeDescriptor> ve);
 
virtual bool canPropagate(vertexDescriptor v);
 
virtual bool canReassignOutcome(vertexDescriptor v);
 
virtual float customSimulationStep(vertexDescriptor v=TransitionSystem::null_vertex()){
    return simulationStep;
}
 
public:
 
AttentiveConfigurator(){};
 
AttentiveConfigurator(Task _task){
    init(_task);
}
 
virtual ~AttentiveConfigurator()=default;
 
 
 
};
 
class FocusedConfigurator: public virtual AttentiveConfigurator{
    protected:
 
    StateMatcher::MATCH_TYPE desiredMatch() override {
        return StateMatcher::MATCH_TYPE::ABSTRACT;
    }   
    void removeExploredTransitions(vertexDescriptor v)override;
    
    bool recycle_plan(vertexDescriptor v, vertexDescriptor &v0, vertexDescriptor & task_start, StateMatcher::MATCH_TYPE &matchType, 
                    b2Transform & shift_start, b2Transform& sk_first_start, std::pair<edgeDescriptor, bool>&edge,
                    std::vector<vertexDescriptor> &plan_prov, Direction t_get_direction)override{
                        return false;
    }
 
    virtual VertexMatch findMatch(State s, Direction dir=Direction::UNDEFINED, StateMatcher::MATCH_TYPE match_type=StateMatcher::_TRUE, StateDifference * _sd=NULL, std::vector <VertexMatch>*other_matches=NULL)override;
 
    void adjust_goal_expectation()override{}
 
    virtual float customSimulationStep(vertexDescriptor v=TransitionSystem::null_vertex())override;
 
    bool hasPlanFinished(){
    return m_plan.empty() && currentTask.is_over();
}
 
};
 
class DiscreteConfigurator : public virtual FocusedConfigurator{
public:
Disturbance getDisturbance(TransitionSystem&g, vertexDescriptor v, b2World & world, const Direction & dir, const b2Transform& start)override;
 
Robot makeRobot(b2World & w, const b2Transform & start)override;
 
float remainingSimulationTime(const Task *const t=NULL)override;
 
VertexMatch findMatch(State s, Direction dir=Direction::UNDEFINED, StateMatcher::MATCH_TYPE match_type=StateMatcher::_TRUE, StateDifference * _sd=NULL, std::vector <VertexMatch>*other_matches=NULL)override;
 
StateMatcher::MATCH_TYPE desiredMatch() override {
    return StateMatcher::MATCH_TYPE::_TRUE;
}
void transitionMatrix(vertexDescriptor v, Direction d, vertexDescriptor src) override;
 
bool closeVertex(std::set<vertexDescriptor> & closed, vertexDescriptor v)override;
 
bool recycle_plan(vertexDescriptor v, vertexDescriptor &v0, vertexDescriptor & task_start, StateMatcher::MATCH_TYPE &matchType, 
                b2Transform & shift_start, b2Transform& sk_first_start, std::pair<edgeDescriptor, bool>&edge,
                std::vector<vertexDescriptor> &plan_prov, Direction t_get_direction)override{
                    return false;
}
 
void backtrack(std::vector <vertexDescriptor>& evaluation_q, std::vector <vertexDescriptor>&priority_q, std::set<vertexDescriptor>& closed, std::vector <vertexDescriptor>& plan_prov, vertexDescriptor module_src, vertexDescriptor startRecycle)override;
 
std::vector<Direction> partiallyExplorativeOptions(std::pair<bool, edgeDescriptor> ve)override;
 
bool shouldPartiallyExplore(const std::vector<edgeDescriptor>& oe, std::pair<bool, edgeDescriptor> ve)override;
 
void removeExploredTransitions(vertexDescriptor v)override;
 
bool canPropagate(vertexDescriptor v) override;
 
bool canReassignOutcome(vertexDescriptor v) override;
 
bool propagateD(vertexDescriptor v1, vertexDescriptor v0, std::set<vertexDescriptor>*closed=NULL, StateMatcher::MATCH_TYPE match=StateMatcher::_FALSE)override;
 
float customSimulationStep(vertexDescriptor v=TransitionSystem::null_vertex()){
    return AttentiveConfigurator::customSimulationStep();
}
 
};
 
// /**
//  * @brief Plans by simply looking ahead at the possible Tasks and choosing the best sequence.
//  * Does not process states, e.g. with split
//  */
// class SimplestConfigurator: public FocusedConfigurator{
//  int simulationStep=BOX2DRANGE;
 
//  Robot makeRobot(b2World & world, const b2Transform & start){
//      return Configurator::makeRobot(world, start);
//  }
 
//  Disturbance getDisturbance(TransitionSystem&g, vertexDescriptor v, b2World & world, const Direction & dir, const b2Transform& start){
//      return g[v].Dn;
//  }
 
//  void backtrack(std::vector <vertexDescriptor>& evaluation_q, std::vector <vertexDescriptor>&priority_q, std::set<vertexDescriptor>& closed, std::vector <vertexDescriptor>& plan_prov, vertexDescriptor module_src=MOVING_VERTEX, vertexDescriptor startRecycle=MOVING_VERTEX);
 
 
 
// };
#endif