/home/slemaign/softs-local/BioMove3D-git/p3d/env.hpp

#ifndef ENV_HPP
#define ENV_HPP

#ifdef QT_LIBRARY
#undef CursorShape
#include <QtCore/QObject>
#endif

#include <map>
#include <utility>
#include <string>
#include <vector>

#include "ParametersEnv.hpp"

class Env
#ifdef QT_LIBRARY
: public QObject
#endif
{
public:
        
#ifdef QT_LIBRARY
        Q_OBJECT;
  Q_ENUMS(boolParameter);
  Q_ENUMS(intParameter);
  Q_ENUMS(doubleParameter);
  Q_ENUMS(stringParameter);
  Q_ENUMS(vectorParameter);
  Q_ENUMS(expansionMethod);
#endif
        
public:
        
        enum boolParameter {
                // Controls wether the C++ planner maps the C Graph or not
                // Only works with RRT
                use_p3d_structures,
                // Controls wether the planner is PRM or Diffusion
                isPRMvsDiffusion,
                isGoalBiased,
                treePlannerIsEST,
                // Controls wether the diffusion method expand towards a given goal.
                expandToGoal,
                // Controls wether the expansion process for bi-RRT is balanced.
                expandBalanced,
                // Controls wether the diffusion method is mono or bidirectional (bi-RRT).
                biDir,
                minimize,
                // Controls wether cycles are added during the diffusion process.
                // Currently, a cycle is added if from a new node,
                // we can find  another node that is far in the graph structure.
                addCycles,
                // Wether the exporation controls the refinement vs expansion nodes
                expandControl,
                // Wether nodes are discarded for selection in RRT,
                // after a maximum number of allowed failures.
                discardNodes,
                //enable or disable edge validation (used in RRT only)
                findLowCostConf,
                // Manhattan-like RRT
                // In a first step only the active parameters are expanded
                // then we try to expand the passive parameter by recursivly
                // expanding  only the passive parameters which were in collision
                // during the previsous expansion
                isManhattan,
                isMultiRRT,
                drawDisabled,
                drawFrame,
                drawGraph,
                drawTraj,
                drawOTPTraj,
                drawTrajVector,
                drawAll,
                drawLightSource,
                drawGrid,
                drawEntireGrid,
                drawDistance,
                drawPoints,
                drawGaze,
                drawBox,
                drawOnlyOneLine,
                drawVectorField,
    drawMultiColorLocalpath,
                // Variables Hri
                useHriDis,
                useHriPen,
                useHriNat,
                enableHri,
                computeGrid,
                HRIPlannerTS,
                HRIPlannerWS,
                HRIPlannerCS,
                HRIPlannerTRRT,
                HRIPathDistance,
                HRIleftArmVsRightArm,
                HRIcameraBehindHuman,
                HRINoRobot,
                HRIComputeOTP,
                HRIAutoLoadGrid,
                // Variable Visualisation
                printTemp,
                printRadius,
                printNbQRand,
                printCollFail,
                printCostFail,
                // Ligand exit trajectory simulation :
                // The rrt expansion is stopped when the distance from start
                // reaches a certain value.
                ligandExitTrajectory,
                useRefiRadius,
                // Cost Traj && Cost Space
                debugCostOptim,
                trajCostRecompute,
                isCostSpace,
                isPasExtWhenAct,
                useDist,
                costBeforeColl,
                costExpandToGoal,
                costThresholdRRT,
                costThresholdPlanner,
                costStarRRT,

                //OTP
                FastComputingRobotBase,
                DrawRobotBaseGridCosts,
                
                // Smoothing stage
                withMaxIteration,
                withGainLimit,
                withTimeLimit,
                withSmoothing,
                withShortCut,
                withDeformation,
                saveTrajCost,
                
                withCleaning,
                
                useTRRT,
                useBoxDist,
                useBallDist,
                isInverseKinematics,
                isRunning,
                initPlot,
                isWeightedRotation,
                randomConnectionToGoal,
                tryClosest,
                StopMultiRun,
                tRrtComputeGradient,
                FKShoot,
                FKDistance,
                RecomputeCellCost,
                UseDPGGrids,
                startWithFKCntrt,
                showOneCell
#ifdef MULTILOCALPATH
                ,plotSoftMotionCurve,
                writeSoftMotionFiles
#endif
        };
        
        enum intParameter {
                // number of consecutive times the optimization
                // of a cost trajectory fails before we stop the
                // optimization
                // WARNING: Currently, this parameter is also
                // used for other applications:
                // - Set the speed of the threshold increase in
                // the MAXIMAL_THRESHOLD variant
                // - Set the temperature in the MONTE_CARLO_SEARCH
                PRMType,
                nbOfSeeds,
    jntToDraw,
                maxCostOptimFailures,
                nbQRand,
                nbCostTransFailed,
                nbCollExpanFailed,
                nbCostOptimize,
                nbGreedyTraj,
                maxNodeCompco,
                maxNode,
                maxConnect,
                NbTry,
                MaxExpandNodeFail,
                MaxPassiveExpand,
                DistConfigChoice,
                ExpansionNodeMethod,
                costMethodChoice,
                test,
                nbRound,
                nbMultiRun,
                nbMultiSmooth,
                akinJntId,
                heightFactor,
                progress,
                costDeltaMethod,
                hriCostType,
                hriActiveGrid,
                hriShownGridLine,
                tRrtNbtry,
                cellToShow,
                lineToShow,
                nbCells,

                //OTP
                typeRobotBaseGrid // 0, 1, 2 or 3 for all, dist only, robot dist only and visual field only
        };
        
        enum doubleParameter {
                // Mirrors the env dmax
                dmax,
                // Frame per seconds in the QT interface
                FPS,
                showTrajFPS,
                // the extension length in the extend method is equal to
                // mExtensionStep*Dmax
                extensionStep,
                costStep,
                costThreshold,
                
                // Controls the increasement of the temperature in Cost Spaces.
                temperatureRate,
                temperatureStart,
                temperatureGoal,
                
                // Temperature parameter of the T-RRT algorithm.
                // (by analogy with simulated annealing methods)
                initialTemperature,
                alpha,
                
                // Variables Hri
                zone_size,
                coeffPen,
                coeffDis,
                coeffNat,
                coeffJoint,
                coeffEnerg,
                coeffConfo,
                coeffArmPr,
                multCost,
                Kdistance,
                Kvisibility,
                Knatural,
                Kreachable,
                KlengthWeight,
                
                // Optimization Variables
                optimTimeLimit,
                MaxFactor,
                MinStep,
                
                //Other variables
                refiRadius,
                manhatRatio,
                dist,
                visThresh,
                PlanCellSize,
                CellSize,
                Bias,
                RotationWeight,
                colorThreshold1,
                colorThreshold2,
                findLowCostThreshold,
                bestCost,
        minimalFinalExpansionGap,
        //Optimisation time
        timeOptimize,

        //OTP
        optimalDist,
        robotMaximalDist,
        gazeAngle,

        optimalDistFactor,
        robotMaximalDistFactor,
        gazeAngleFactor
        };
        
        enum stringParameter {
                nameOfFile,
                numberOfCollisionPerSec,
                numberOfLocalPathPerSec,
                numberOfCostPerSec,
                ObjectToCarry,
                ActiveGrid
        };
        
        enum  vectorParameter {
                costAlongTraj
        };
        
        enum expansionMethod {
                Extend,
                nExtend,
                Connect,
                costConnect
        };
        
        Env();
        
        ~Env();
        
#ifdef QT_LIBRARY

        QString getString(stringParameter p);
        
        void setString(stringParameter p, QString v);
#endif
        
        std::vector<double> getVector(vectorParameter p);
        
        void setVector(vectorParameter p, std::vector<double> v);
        
        int getInt(intParameter p);
        
        void setInt(intParameter p, int v);
        
        double getDouble(doubleParameter p);
        
        void setDouble(doubleParameter p, double v);
        
        bool getBool(boolParameter p);
        
        void setBool(boolParameter p, bool v);
        
#ifdef QT_LIBRARY
        QObject* getObject(intParameter p);
#endif
        
#ifdef QT_LIBRARY
        QObject* getObject(boolParameter p);
#endif
        
#ifdef QT_LIBRARY
        QObject* getObject(doubleParameter p);
#endif
        
#ifdef QT_LIBRARY
        QObject* getObject(stringParameter p);
#endif
        
#ifdef QT_LIBRARY
        QObject* getObject(vectorParameter p);
#endif
        
        
        void setExpansionMethod(expansionMethod method);
        
        expansionMethod getExpansionMethod();
        
        
        typedef std::pair<intParameter, intContainer*> intMap_t;
        typedef std::pair<stringParameter, stringContainer*> stringMap_t;
        typedef std::pair<vectorParameter, vectorContainer*> vectorMap_t;
        typedef std::pair<doubleParameter, doubleContainer*> doubleMap_t;
        typedef std::pair<boolParameter, boolContainer*> boolMap_t;
        
        std::map<intParameter, intContainer*>                                   getIntMap() {return mIntMap; }
        std::map<stringParameter, stringContainer*>     getStringMap() {return mStringMap; }
        std::map<vectorParameter, vectorContainer*>     getVectorMap() {return mVectorMap; }
        std::map<doubleParameter, doubleContainer*>     getDoubleMap() {return mDoubleMap; }
        std::map<boolParameter, boolContainer*>                         getBoolMap() {return mBoolMap; }
        
        
#ifdef QT_LIBRARY
        public slots:
#endif

        void setExpansionMethodSlot(int method);
        
#ifdef QT_LIBRARY
signals:
#endif

        void expansionMethodChanged(int method);
        
        
private:
        std::map<intParameter,          intContainer*>                          mIntMap;
        std::map<stringParameter, stringContainer*>                     mStringMap;
        std::map<vectorParameter, vectorContainer*>                     mVectorMap;
        std::map<doubleParameter, doubleContainer*>                     mDoubleMap;
        std::map<boolParameter,         boolContainer*>                         mBoolMap;
        
        
        /*The method used to expand a node toward a direction
         configuration selected as direction of expansion*/
        expansionMethod mExpansionMethod;
        
};

extern Env ENV;

#endif