BaseExpansion.hpp

/*
 * BaseExpansion.hpp
 *
 *  Created on: Jun 11, 2009
 *      Author: jmainpri
 */
#ifndef P3D_BASE_EXPANSION_HPP
#define P3D_BASE_EXPANSION_HPP

#include "API/ConfigSpace/configuration.hpp"

#include "../p3d/env.hpp"

#ifndef LOCALPATH_HPP
class LocalPath;
#endif

#ifndef GRAPH_HPP
class Graph;
#endif

#ifndef NODE_HPP
class Node;
#endif

class BaseExpansion 
{
public:
        
        BaseExpansion();
        BaseExpansion(Graph* prtGraph);
        
        ~BaseExpansion();
        
        void setGraph(Graph* G) { m_Graph = G; }
        
        Graph* getGraph() { return m_Graph; }
        
        int getDirectionMethod() { return m_ExpansionDirectionMethod; }
        
        void setDirectionMethod(int directionExpansion) { m_ExpansionDirectionMethod = directionExpansion; }
        
        int getNodeMethod() { return m_ExpansionNodeMethod; }
        
        void setNodeMethod(int nodeExpansion) { m_ExpansionNodeMethod = nodeExpansion; }
        
        void setFromComp(Node* fromComp) { m_fromComp = fromComp; }  
        
        Node* getFromComp() { return m_fromComp; }
        
        void setToComp(Node* toComp) { m_toComp = toComp; }  
        
        Node* getToComp() { return m_toComp; }
        
        double step();

        double getDMax();

        double computeInterpolationFactor(double pathLength) {
                return (pathLength == 0.) ? 1. : std::min(1., this->step() / pathLength );
        }

        confPtr_t interpolate(confPtr_t conf, LocalPath * path, double factor);

        double positionAlongPath(LocalPath& path, double param);
        
        double pathDelta(LocalPath& path);
        
        LocalPath getExtensiontPath(std::tr1::shared_ptr<Configuration> qi,
                                                                                                                        std::tr1::shared_ptr<Configuration> qf );
        
        void expansionFailed(Node& node);
        
        virtual Node* addNode(Node* currentNode, LocalPath& path, double pathDelta,
                                                                                                Node* directionNode, unsigned& nbCreatedNodes);
        
        bool refinementControl(LocalPath& path, double rho, Node& compNode);

        bool nextStep(LocalPath& path,
                                                                std::tr1::shared_ptr<Configuration>& directionConfig,
                                                                double& pathDelta,
                                                                std::tr1::shared_ptr<LocalPath>& newPath,
                                                                Env::expansionMethod method);
        
        bool nextStep(LocalPath& path,
                                                                Node* directionNode,
                                                                double& pathDelta,
                                                                std::tr1::shared_ptr<LocalPath>& newPath,
                                                                Env::expansionMethod method);
        
        virtual Node* getExpansionNode(Node* compNode, confPtr_t direction, int distance);

        std::tr1::shared_ptr<Configuration> getExpansionDirection(Node* expandComp, Node* goalComp,
                bool samplePassive, Node*& directionNode);

    Node* getLasAddedNode() {
        return m_last_added_node;
    }

    void addConnectibleNode(){
        _nbConnectibleNodes++;
    }

    unsigned int getNbConnectibleNodes(){
        return _nbConnectibleNodes;
    }

protected:
        
        int m_ExpansionNodeMethod;
        int m_MaxExpandNodeFailure;
        int m_kNearestPercent;
        
        int m_ExpansionDirectionMethod; // = GLOBAL_CS_EXP;
        bool m_IsDirSampleWithRlg; //= FALSE;
        
        Graph* m_Graph;

        Node* m_last_added_node;

        Node* m_fromComp;
        Node* m_toComp;

    unsigned int _nbConnectibleNodes;
};

#endif