focused.h

#ifndef FOCUSED_H
#define FOCUSED_H
#include "configurator.h"
 
class FocusedConfigurator:public virtual Configurator{
    protected:
    StateMatcher* matcher=new StateMatcher();
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);
 
//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 hardMatch(State s, Direction dir=Direction::UNDEFINED, StateMatcher::MATCH_TYPE match_type=StateMatcher::_TRUE, StateDifference * _sd=NULL); //matches to most likely
 
 
virtual VertexMatch findMatch(State s, Direction dir=Direction::UNDEFINED, StateMatcher::MATCH_TYPE match_type=StateMatcher::_TRUE, StateDifference * _sd=NULL, vertexDescriptor src=TransitionSystem::null_vertex()); //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 bool preventTransition(vertexDescriptor v){
    return v==currentVertex && (!m_plan.empty()||!currentTask.is_over());
}
 
virtual void removeExploredTransitions(vertexDescriptor v);
 
void removePointlessTransitions(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);
 
vertexDescriptor getNextSrc(const std::vector<vertexDescriptor>& q);
 
//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){
                    return false;
                }
 
 
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);
 
// /**
//  * @brief  if the match is a crashed task
//  * 
//  * @param match 
//  * @param other_matches 
//  * @return true if changes match
//  */
// 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);
 
bool isPreviousState(const State & s, const State & candidate);
// /**
//  * @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);
 
bool 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 Task & task);
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());
 
 
bool hasPlanFinished(){
    return m_plan.empty() && currentTask.is_over();
}
 
public:
 
void adjust_goal_expectation()override{}
 
FocusedConfigurator(){};
 
FocusedConfigurator(Task _task){
    init(_task);
}
 
virtual ~FocusedConfigurator(){
    delete matcher;
    matcher=NULL;
}
 
 
 
};
 
#endif