CommandFollowKinematicTrajectory.h

Go to the documentation of this file.

#ifndef ConscienceEnvironmentInteractionCommandFollowKinematicTrajectory_h
#define ConscienceEnvironmentInteractionCommandFollowKinematicTrajectory_h
 
#include "./Command.h"
#include "Parser/CscCommandAutoParse.h"
 
using std::string;
using std::vector;
 
namespace conscience_core::bridging::commands {
    class CSC_DLL_IMPORTEXPORT CommandFollowKinematicTrajectory: public CscCommand {
 
    public:
        inline static const CommandTypeId COMMAND_ID = "FOLLOW_KINEMATIC_TRAJECTORY";
 
        CommandFollowKinematicTrajectory(
            ptr<CscEntityReflexion> entityReflexion,
            
            int knowledgeId,
            const CscState *currentState,
            string membreToMove,
            string membreRelative,
            string targetEntityObjectName,
            /*
             shapeWithObject allow to chose wich shape the different object draw in space.
             There are two possibilities : line or sinusoid
             */
            string shapeWithObject,
            /*
             The different shapeBegin  X, Y and Z allow to chose first object’s position
             */
            float shapeBeginX,
            float shapeBeginY,
            float shapeBeginZ,
            /*
             The different direction X, Y or Z allow to chose objects’ directions.
             With the shape line is simply the line’s leading coefficients from shapeBegin X, Y and Z.
             With the shape sinusoid is directionX and directionY is the sinusoid’s amplitude in X and Y, directionZ is for the step value in Z (of object) = cos(i) * directionZ with i == a multiple of 0.3
             */
            float directionX,
            float directionY,
            float directionZ,
            /*
             Positionnement to reach with membreToMove in X, Y and Z
             */
            float distanceFromTargetX,
            float distanceFromTargetY,
            float distanceFromTargetZ,
            /*
             euler objective in X,Y and Z to reach with membreToMove
             */
            float targetEulerX,
            float targetEulerY,
            float targetEulerZ,
            /*
            Positionnement ponderation for evaluation to reach with membreToMove in X, Y and Z
            */
            float distanceFromTargetPonderationX,
            float distanceFromTargetPonderationY,
            float distanceFromTargetPonderationZ,
            /*
             euler ponderation objective for evaluation in X,Y and Z to reach with membreToMove
             */
            float targetEulerPonderationX,
            float targetEulerPonderationY,
            float targetEulerPonderationZ,
            /*
             duration of each state
             */
            float stateDuration,
            /*
             duration between each state
             */
            float stateDelay,
            float processAt);
        
        ~CommandFollowKinematicTrajectory() {
            delete currentState;
        }
 
        int getKnowledgeId();
        const CscState *getCurrentState();
        string getMembreToMove();
        string getMembreRelative();
        string getTargetEntityObjectName();
        float getDistanceFromTargetX();
        float getDistanceFromTargetY();
        float getDistanceFromTargetZ();
        float getTargetEulerX();
        float getTargetEulerY();
        float getTargetEulerZ();
        float getDistanceFromTargetPonderationX();
        float getDistanceFromTargetPonderationY();
        float getDistanceFromTargetPonderationZ();
        float getTargetEulerPonderationX();
        float getTargetEulerPonderationY();
        float getTargetEulerPonderationZ();
 
    protected:
        const CscCommandExecutionResultSequence * doExecute(CscEnvironmentSimulator &environmentSimulator) override;
        ptr<CscEntityReflexion> getEntityReflexion() const override {
            return entityReflexion;
        }
    private:
 
        ptr<CscEntityReflexion> entityReflexion;
 
        const int knowledgeId;
        const CscState *const currentState;
        const string membreToMove;
        const string membreRelative;
        const string targetEntityObjectName;
        const string shapeWithObject;
        const float shapeBeginX;
        const float shapeBeginY;
        const float shapeBeginZ;
        const float directionX;
        const float directionY;
        const float directionZ;
        const float distanceFromTargetX;
        const float distanceFromTargetY;
        const float distanceFromTargetZ;
        const float targetEulerX;
        const float targetEulerY;
        const float targetEulerZ;
        const float distanceFromTargetPonderationX;
        const float distanceFromTargetPonderationY;
        const float distanceFromTargetPonderationZ;
        const float targetEulerPonderationX;
        const float targetEulerPonderationY;
        const float targetEulerPonderationZ;
        bool outputTypes[4];
        const float processAt;
        const float stateDuration;
        const float stateDelay;
    };
 
COMMAND_REGISTER(CommandFollowKinematicTrajectory,
            ptr<CscEntityReflexion>,
            int,
            const CscState *,
            string,
            string,
            string,
            string,
            float,
            float,
            float,
            float,
            float,
            float,
            float,
            float,
            float,
            float,
            float,
            float,
            float,
            float,
            float,
            float,
            float,
            float,
            float,
            float,
            float);
 
}
 
#endif