ROSEE::ActionComposed Class Reference

A ActionComposed, which is formed by one or more Primitives (or even other composed). More...

#include <ActionComposed.h>

Inheritance diagram for ROSEE::ActionComposed:

Collaboration diagram for ROSEE::ActionComposed:

Public Types
typedef std::shared_ptr< ActionComposed >	Ptr
typedef std::shared_ptr< const ActionComposed >	ConstPtr
Public Types inherited from ROSEE::ActionGeneric
typedef std::shared_ptr< ActionGeneric >	Ptr
typedef std::shared_ptr< const ActionGeneric >	ConstPtr
Public Types inherited from ROSEE::Action
enum	Type {   Primitive,   Generic,   Composed,   Timed,   None }
	Enum useful to discriminate each action when, for example, we want to parse a file if you change this enum, change also the ROSEEControl.msg accordingly. More...
typedef std::shared_ptr< Action >	Ptr
typedef std::shared_ptr< const Action >	ConstPtr

Public Member Functions
	ActionComposed ()
	ActionComposed (std::string name)
	ActionComposed (std::string name, bool independent)
	ActionComposed (const ActionComposed &other)
	Copy costructor. More...
unsigned int	numberOfInnerActions () const
bool	isIndependent () const
std::vector< std::string >	getInnerActionsNames () const
virtual void	print () const override
	Print info about this action (name, jointpos, inner actions names, and other) More...
virtual void	emitYaml (YAML::Emitter &out) const override
	Emit info in a file with yaml format. More...
virtual bool	fillFromYaml (YAML::const_iterator yamlIt) override
	Fill the internal data with infos taken from yaml file. More...
virtual bool	sumAction (ROSEE::Action::Ptr action, double jointPosScaleFactor=1.0, unsigned int jointPosIndex=0)
	Function to add another action to this one. More...
bool	empty ()
	Check if the action composed is empty. More...
Public Member Functions inherited from ROSEE::ActionGeneric
	ActionGeneric ()
	default costructor. More...
	ActionGeneric (std::string actionName, ROSEE::JointPos jointPos)
	Simpliest costructor, need only essential infos. More...
	ActionGeneric (std::string actionName, ROSEE::JointPos jointPos, JointsInvolvedCount jic)
	Another costructor. More...
	ActionGeneric (std::string actionName, ROSEE::JointPos jointPos, JointsInvolvedCount jic, std::set< std::string > fingersInvolved)
JointPos	getJointPos () const override
	Get the joint position related to this action, overriden from Action. More...
std::vector< ROSEE::JointPos >	getAllJointPos () const override
	Get the joint position related to this action, overriden from Action Necessary to not make this class abstact, even if for a composed action we store only a single JointPos, so this function return a single element vector. More...
Public Member Functions inherited from ROSEE::Action
virtual	~Action ()
std::string	getName () const
	Get the name of the action. More...
Type	getType () const
std::set< std::string >	getFingersInvolved () const
	Get for fingersInvolved. More...
JointsInvolvedCount	getJointsInvolvedCount () const
	Get for jointsInvolvedCount. More...

Protected Member Functions
bool	checkIndependency (ROSEE::Action::Ptr action)
Protected Member Functions inherited from ROSEE::ActionGeneric
	ActionGeneric (std::string actionName)
	this costructor is only for derived class More...
Protected Member Functions inherited from ROSEE::Action
	Action ()
	Action (std::string actionName, Action::Type type)

Protected Attributes
std::vector< std::string >	innerActionsNames
unsigned int	nInnerActions
bool	independent
Protected Attributes inherited from ROSEE::ActionGeneric
JointPos	jointPos
Protected Attributes inherited from ROSEE::Action
std::string	name
Action::Type	type
std::set< std::string >	fingersInvolved
JointsInvolvedCount	jointsInvolvedCount

Detailed Description

A ActionComposed, which is formed by one or more Primitives (or even other composed).

It is useful for example to create an action that grasp only with bending the tips (e.g. to take a dish from above) If the ActionComposed has the boolean value independent to true, it means that include indipendent sub-actions, so, each joint is used by at maximum by ONLY ONE of the sub-action inside. In this case the jointsInvolvedCount will contain only 0 or 1 values. If the ActionComposed is not independent, each joint position is calculated as the mean of all the joint position of the contained sub-actions that uses that joint. So each mean can include different primitives, so we used the jointsInvolvedCount vector to store the number of sub action that use each joint.

Todo:

A removeAction function? difficult to implement, and useless?

Definition at line 44 of file ActionComposed.h.

Member Typedef Documentation

typedef std::shared_ptr<const ActionComposed> ROSEE::ActionComposed::ConstPtr

Definition at line 49 of file ActionComposed.h.

typedef std::shared_ptr<ActionComposed> ROSEE::ActionComposed::Ptr

Definition at line 48 of file ActionComposed.h.

Constructor & Destructor Documentation

ROSEE::ActionComposed::ActionComposed

(

)

Definition at line 21 of file ActionComposed.cpp.

                                    : ActionGeneric() {
    independent = true;
    nInnerActions = 0;
    type = Action::Type::Composed;
}

ROSEE::ActionComposed::ActionComposed

(

std::string

name

)

Definition at line 27 of file ActionComposed.cpp.

                                                  : ActionGeneric(name) {
    independent = true;
    nInnerActions = 0;
    type = Action::Type::Composed;
}

ROSEE::ActionComposed::ActionComposed	(	std::string	name,
		bool	independent
	)

Definition at line 33 of file ActionComposed.cpp.

                                                                    : ActionGeneric(name) {
    this->independent = independent;
    nInnerActions = 0;
    type = Action::Type::Composed;
}

ROSEE::ActionComposed::ActionComposed

(

const ActionComposed &

other

)

Copy costructor.

Member Function Documentation

bool ROSEE::ActionComposed::checkIndependency ( ROSEE::Action::Ptr  action )

protected

Definition at line 147 of file ActionComposed.cpp.

                                                                    {
    
    if (!independent) {
        
    } else if (nInnerActions == 0 ) {
        
        for ( auto jic : action->getJointsInvolvedCount() ){
            if ( jic.second  > 1  ) {
                // if action is dependent we check that all its joints are setted only once
                // so we can teoretically add a "dipendent" action if all its joints are setted once
                return false; //cant add this primitive
            }
        }
        
    } else {   
    
        for ( auto jic : action->getJointsInvolvedCount() ){
            if ( jic.second + jointsInvolvedCount.at(jic.first) > 1  ) {
                // we use the sum so also if action is dependent we check that all its joints are setted once
                // so we can teoretically add a "dipendent" action if all its joints are setted once
                return false; //cant add this primitive
            }
        }
    }
    
    return true;
}

void ROSEE::ActionComposed::emitYaml ( YAML::Emitter &  out ) const

overridevirtual

Emit info in a file with yaml format.

Parameters

out	a YAML::Emitter& object to emit the infos

Reimplemented from ROSEE::ActionGeneric.

Definition at line 208 of file ActionComposed.cpp.

                                                           {
    
    out << YAML::BeginMap << YAML::Key << name << YAML::Value << YAML::BeginMap ;
        out << YAML::Key << "Type" << YAML::Value << type;
        out << YAML::Key << "Independent" << YAML::Value << independent;
        out << YAML::Key << "NInnerActions" << YAML::Value << nInnerActions;
        out << YAML::Key << "InnerActionsNames" << YAML::Value << YAML::Flow << innerActionsNames;
        out << YAML::Key << "FingersInvolved" << YAML::Value << YAML::Flow << fingersInvolved;
        out << YAML::Key << "JointsInvolvedCount" << YAML::Value << YAML::BeginMap;
        for (const auto &jointCount : jointsInvolvedCount ) {
            out << YAML::Key << jointCount.first;
            out << YAML::Value << jointCount.second;
        } 
        out << YAML::EndMap;

        out << YAML::Key << "JointPos" << YAML::Value << YAML::BeginMap;
            for (const auto &joint : jointPos) {
                out << YAML::Key << joint.first;
                out << YAML::Value << YAML::Flow << joint.second; //vector of double is emitted like Seq
            }
        out << YAML::EndMap;
    out << YAML::EndMap;
    out << YAML::EndMap;
}

bool ROSEE::ActionComposed::empty

(

)

Check if the action composed is empty.

Returns

true if empty, false otherwise

Definition at line 51 of file ActionComposed.cpp.

                                {
    return (nInnerActions == 0);
}

bool ROSEE::ActionComposed::fillFromYaml ( YAML::const_iterator  yamlIt )

overridevirtual

Fill the internal data with infos taken from yaml file.

Parameters

yamlIt

a yamlt iterator to a node which has loaded the file

Returns

false if some error happened

Reimplemented from ROSEE::ActionGeneric.

Definition at line 234 of file ActionComposed.cpp.

                                                                   {
    
    name = yamlIt->first.as<std::string>();
            
    for (auto keyValue = yamlIt->second.begin(); keyValue != yamlIt->second.end(); ++keyValue ) {

        std::string key = keyValue->first.as<std::string>();

        if ( key.compare ("Independent") == 0 ) {
            independent = keyValue->second.as<bool>();
            
        } else if ( key.compare ("NInnerActions") == 0 ) {
            nInnerActions = keyValue->second.as <unsigned int>();
            
        } else if ( key.compare ("Type") == 0 ) {
            if (ROSEE::Action::Type::Composed != static_cast<ROSEE::Action::Type> ( keyValue->second.as <unsigned int>() )) {
                std::cout << "[COMPOSED ACTION::" << __func__ << "] Error, found type  " << keyValue->second.as <unsigned int>()
                << "instead of Composed type (" << ROSEE::Action::Type::Composed << ")" << std::endl;
                return false;
            }
            type = ROSEE::Action::Type::Composed;
            
        } else if ( key.compare ("InnerActionsNames") == 0 ) {
            innerActionsNames = keyValue->second.as <std::vector <std::string> >();
        
        } else if ( key.compare ("FingersInvolved") == 0 ) { 
            auto tempVect = keyValue->second.as <std::vector <std::string> > ();
            fingersInvolved.insert ( tempVect.begin(), tempVect.end() );
            
        } else if ( key.compare ("JointsInvolvedCount") == 0 ) {
            jointsInvolvedCount = keyValue->second.as < JointsInvolvedCount >(); 
            
        } else if ( key.compare ("JointPos") == 0 ) {
            jointPos = keyValue->second.as < JointPos >();
            
        } else {
            std::cout << "[COMPOSED ACTION PARSER] Error, not known key " << key << std::endl;
            return false;
        }
    } 
    return true;
}

std::vector< std::string > ROSEE::ActionComposed::getInnerActionsNames

(

)

const

Returns

std::vector <std::string> all the names that compose this action

Definition at line 47 of file ActionComposed.cpp.

                                                                     {
    return innerActionsNames;
}

bool ROSEE::ActionComposed::isIndependent

(

)

const

Returns

bool true if this action must contain only independent primitives

Definition at line 43 of file ActionComposed.cpp.

                                              {
    return independent;
}

unsigned int ROSEE::ActionComposed::numberOfInnerActions

(

)

const

Returns

unsigned int the number of the actions that compose this one

Definition at line 39 of file ActionComposed.cpp.

                                                             {
    return nInnerActions;
}

void ROSEE::ActionComposed::print ( ) const

overridevirtual

Print info about this action (name, jointpos, inner actions names, and other)

Reimplemented from ROSEE::Action.

Definition at line 176 of file ActionComposed.cpp.

                                       {
    
    std::stringstream output;
    
    output << "Composed Action '" << name;
    independent ? output << "' (independent):" : output << "' (not independent):" ;
    output << std::endl;
    
    output << "Composed by " << nInnerActions << " inner action: [" ;
    for (auto it : innerActionsNames) {
        output << it << ", ";
    }
    output.seekp (-2, output.cur); //to remove the last comma (and space)
    output << "]" << std::endl;
    
    output << "Fingers involved: [" ;
    for (auto it : fingersInvolved) {
        output << it << ", ";
    }
    output.seekp (-2, output.cur); //to remove the last comma (and space)
    output << "]" << std::endl;
    
    output << "Each joint influenced by x inner action:" << std::endl;
    output << jointsInvolvedCount;

    output << "JointPos:" << std::endl;
    output << jointPos << std::endl;
    
    std::cout << output.str();
}

bool ROSEE::ActionComposed::sumAction ( ROSEE::Action::Ptr  action, double  jointPosScaleFactor = 1.0, unsigned int  jointPosIndex = 0  )

virtual

Function to add another action to this one.

Parameters

action	The action to be added to the ActionComposed
jointPosScaleFactor	How much scale the joint position values for the action to be inserted. Default to 1
jointPosIndex	(default == 0) the wanted jointPos or action to insert. Error the index is greater than the number of joint pos in the action. First element has index 0.

Returns

False if the ActionComposed is independent and we try to add an action that is dependent from one of the already present

Definition at line 56 of file ActionComposed.cpp.

{
    
    if ( ! checkIndependency(action) ) {
        return false; //cant add this primitive
    }
    
    if ( jointPosIndex > action->getAllJointPos().size()-1 ) {
        std::cerr << "[ACTIONCOMPOSED:: " << __func__ << "] The given jointPosindex " << jointPosIndex  
            << " exceed the number  " << action->getAllJointPos().size() << " of jointpos of passed action" << std::endl;
        return false;
    }
    
    if ( nInnerActions > 0 && 
        (! ROSEE::Utils::keys_equal(action->getAllJointPos().at(jointPosIndex), jointPos)) ) {
        std::cerr << "[ACTIONCOMPOSED:: " << __func__ << "] The action passed as argument has different keys in jointPosmap" 
                  << " respect to the others inserted in this composed action " << std::endl;
        return false;
    }
    
    if (jointPosScaleFactor < 0) {
        std::cerr << "[ACTIONCOMPOSED:: " << __func__ << "] You can not scale the joint position of the action to be inserted by a " 
                  <<  "value less than 0; jointPosScaleFactor passed is: " << jointPosScaleFactor << std::endl;
        return false;
    } 
    
    if (jointPosScaleFactor > 1) {
        std::wcerr << "[ACTIONCOMPOSED:: " << __func__ << "] WARNING, You are scaling with a value greater than 1 " 
                   << " this could cause to command position over the joint limits;  jointPosScaleFactor passed is: " << jointPosScaleFactor << std::endl;
    } 

    JointPos actionJP = action->getAllJointPos().at(jointPosIndex) * jointPosScaleFactor;
    JointsInvolvedCount actionJIC = action->getJointsInvolvedCount();
        
    if (nInnerActions == 0) { //first primitive inserted
        
        for (auto joint : actionJP ){
            jointsInvolvedCount.insert ( std::make_pair (joint.first, actionJIC.at(joint.first) ) );
            jointPos.insert ( std::make_pair (joint.first, joint.second) );
        }
        
    } else {
        
        if (independent) {

            //if here, action is independent, we can add the joints states
            for ( auto joint : actionJP ){ 
                
                if ( actionJIC.at (joint.first ) > 0 ) {
                    
                    jointPos.at(joint.first) = joint.second;
                    jointsInvolvedCount.at(joint.first) += actionJIC.at (joint.first );
                    //+= or = is the same for the checks done before 
                } 
            }
            
        } else {
            // for each joint, add the state's value to the mean 
            // (number of element in the previous mean is given by jointsInvolvedCount.at(x))

            for ( auto joint : actionJP ) { 
                if ( actionJIC.at( joint.first ) == 0 ) {
                    continue; //if the action that is being added has this joint not setted, not consider it
                }
                
                //update the count 
                jointsInvolvedCount.at(joint.first) += actionJIC.at (joint.first ); 
                
                //iterate all dofs of jointPos
                for (unsigned int dof = 0; dof < joint.second.size(); dof++ ) {
                    
                    double mean = jointPos.at( joint.first ).at(dof) + 
                        ( (joint.second.at(dof) - jointPos.at(joint.first).at(dof)) / 
                            jointsInvolvedCount.at(joint.first) );
                        
                    jointPos.at(joint.first).at(dof) = mean;     
                }
            }
        }
    }
    
    innerActionsNames.push_back ( action->getName() );
    for ( auto it: action->getFingersInvolved() ) {
         fingersInvolved.insert ( it );
    }

    nInnerActions ++;
    
    return true;
}

Member Data Documentation

bool ROSEE::ActionComposed::independent

protected

Definition at line 116 of file ActionComposed.h.

std::vector< std::string > ROSEE::ActionComposed::innerActionsNames

protected

Definition at line 113 of file ActionComposed.h.

unsigned int ROSEE::ActionComposed::nInnerActions

protected

Definition at line 114 of file ActionComposed.h.

---

The documentation for this class was generated from the following files:

• /home/travis/build/ADVRHumanoids/ROSEndEffector/include/end_effector/GraspingActions/ActionComposed.h
• /home/travis/build/ADVRHumanoids/ROSEndEffector/src/GraspingActions/ActionComposed.cpp