ROSEE::ActionMultiplePinchTight Class Reference

Class to describe the action of "pinching" with more than 2 tips (with 2 tips there is the ActionPinchTight and ActionPinchLoose The number of the finger used is fixed when the object is costructed, and it is stored in the father member nFingersInvolved. More...

#include <ActionMultiplePinchTight.h>

Inheritance diagram for ROSEE::ActionMultiplePinchTight:

Collaboration diagram for ROSEE::ActionMultiplePinchTight:

Classes
struct	depthComp
	struct to put in order the actionStates. More...

Public Types
typedef std::map< std::set< std::string >, ActionMultiplePinchTight >	Map
typedef std::pair< JointPos, double >	StateWithDepth
	A pair to "link" the JointPos with the depthSum info to order the StateWithDepth in the actionState set. More...
Public Types inherited from ROSEE::ActionPrimitive
enum	Type {   PinchTight,   PinchLoose,   MultiplePinchTight,   Trig,   TipFlex,   FingFlex,   SingleJointMultipleTips,   None }
	Enum useful to discriminate each primitive 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< ActionPrimitive >	Ptr
typedef std::shared_ptr< const ActionPrimitive >	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
	ActionMultiplePinchTight ()
	ActionMultiplePinchTight (unsigned int maxStoredActionStates)
	ActionMultiplePinchTight (std::set< std::string >, JointPos, double depthSum)
JointPos	getJointPos () const override
	Get the position related to this action. More...
JointPos	getJointPos (unsigned int index) const
std::vector< ROSEE::JointPos >	getAllJointPos () const override
	Return all the joint position stored. More...
std::vector< ROSEE::ActionMultiplePinchTight::StateWithDepth >	getActionStates () const
	Specific get for the ActionMultiplePinchTight to return the state with the paired depthSum. More...
bool	insertActionState (JointPos, double depthSum)
	function to insert a single action in the actionStates set of possible action. More...
void	print () const override
	Overridable functions, if we want to make them more action-specific. More...
void	emitYaml (YAML::Emitter &) const override
	Function to fill the argument passed with info about the action. More...
bool	fillFromYaml (YAML::const_iterator yamlIt) override
	function to fill members of the Action with infos taken from yaml files More...
Public Member Functions inherited from ROSEE::ActionPinchGeneric
	ActionPinchGeneric (std::string name, ActionPrimitive::Type type)
	KNOW the distance at a certain percentage? so se volgio prendere un oggetto largo 3 cm il programma sa quale è la percentage per avere una distanza di 3cm More...
	ActionPinchGeneric (std::string name, unsigned int maxStoredActionStates, ActionPrimitive::Type type)
	ActionPinchGeneric (std::string name, unsigned int nFingerInvolved, unsigned int maxStoredActionStates, ActionPrimitive::Type type)
std::set< std::string >	getKeyElements () const override
	Necessary method to know the key used by the maps which store all the Actions of one type. More...
Public Member Functions inherited from ROSEE::ActionPrimitive
virtual	~ActionPrimitive ()
Type	getPrimitiveType () const
unsigned int	getMaxStoredActionStates () const
unsigned int	getnFingersInvolved () const
void	setJointsInvolvedCount (ROSEE::JointsInvolvedCount jointsInvolvedCount)
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...

Private Attributes
std::set< StateWithDepth, depthComp >	actionStates
	For each multiple pinch possible, we want a set of action because we want to store (in general) more possible way to do that action with that X fingers. More...

Additional Inherited Members
Protected Member Functions inherited from ROSEE::ActionPrimitive
	ActionPrimitive (std::string name, unsigned int maxStoredActionStates, Type type)
	ActionPrimitive (std::string name, unsigned int nFingersInvolved, unsigned int maxStoredActionStates, Type type)
	Protected costructor: object creable only by derived classes. More...
Protected Member Functions inherited from ROSEE::Action
	Action ()
	Action (std::string actionName, Action::Type type)
Protected Attributes inherited from ROSEE::ActionPrimitive
unsigned int	nFingersInvolved
const unsigned int	maxStoredActionStates
const Type	primitiveType
Protected Attributes inherited from ROSEE::Action
std::string	name
Action::Type	type
std::set< std::string >	fingersInvolved
JointsInvolvedCount	jointsInvolvedCount

Detailed Description

Class to describe the action of "pinching" with more than 2 tips (with 2 tips there is the ActionPinchTight and ActionPinchLoose The number of the finger used is fixed when the object is costructed, and it is stored in the father member nFingersInvolved.

A pinchMultipleTight is defined by:

• X tips ( that are inside fingersInvolved member of Action ), so nFingersInvolved == X ( members of base class ActionPrimitive )
• JointStates position: where the collision among the tips happens (inside actionStates )
• Optional info (inside actionStates ): the sum of the depth of compenetration of all the tip pairs that collide.

Note

When exploring the model to find this action, there are two possibility: we can look for a position where all the X fingertips collide among each other (causing EXACTLY bynomial_coeff(X, 2) collisions pair), or, with a "less strict" condition, a position where not all fingertips must collide between each other (causing AT LEAST X-1 collisions). The default is the "more strict" condition, because it can find "better looking" mulPinches, even if obviously we find less possible way to perform the action. With this, it seems better to order the actionState considering as "best" the position where the tips collide less, i.e. where the depthSum is lower. This is the opposite from the normal tight pinch. This cause anyway a collision, but not a ugly one where the tips compenetrate too much. This thing can change if we invert the sign in the depthComp comparison

Definition at line 48 of file ActionMultiplePinchTight.h.

Member Typedef Documentation

typedef std::map< std::set<std::string>, ActionMultiplePinchTight > ROSEE::ActionMultiplePinchTight::Map

Definition at line 53 of file ActionMultiplePinchTight.h.

typedef std::pair<JointPos, double> ROSEE::ActionMultiplePinchTight::StateWithDepth

A pair to "link" the JointPos with the depthSum info to order the StateWithDepth in the actionState set.

Definition at line 56 of file ActionMultiplePinchTight.h.

Constructor & Destructor Documentation

ROSEE::ActionMultiplePinchTight::ActionMultiplePinchTight

(

)

Definition at line 21 of file ActionMultiplePinchTight.cpp.

                                                        : 
    ActionPinchGeneric ("multiplePinchTight", 3, ActionPrimitive::Type::MultiplePinchTight) { }

ROSEE::ActionMultiplePinchTight::ActionMultiplePinchTight

(

unsigned int

maxStoredActionStates

)

Definition at line 24 of file ActionMultiplePinchTight.cpp.

                                                                                          : 
    ActionPinchGeneric ("multiplePinchTight", maxStoredActionStates, ActionPrimitive::Type::MultiplePinchTight) { }

ROSEE::ActionMultiplePinchTight::ActionMultiplePinchTight	(	std::set< std::string >	fingerNamesSet,
		JointPos	jp,
		double	depthSum
	)

Definition at line 27 of file ActionMultiplePinchTight.cpp.

                                  :
    ActionPinchGeneric ( ("multiplePinchTight_" + std::to_string(fingerNamesSet.size())),
                        fingerNamesSet.size(), 3, ActionPrimitive::Type::MultiplePinchTight )  {

    //different from insertState, here we are sure the set is empty (we are in costructor)
    fingersInvolved = fingerNamesSet;
    actionStates.insert (std::make_pair (jp, depthSum) );
}

Member Function Documentation

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

overridevirtual

Function to fill the argument passed with info about the action.

Pure virtual because each derived class has different infos and stored differently. check YamlWorker to correctly emit and parse the file

Parameters

out	the yaml-cpp emitter which store infos about the action

Note

this function does not print in a file, but simply fill a YAML::Emitter.

Reimplemented from ROSEE::ActionPrimitive.

Definition at line 140 of file ActionMultiplePinchTight.cpp.

                                                                      {
    
    out << YAML::Key << YAML::Flow << fingersInvolved;
    
    unsigned int nCont = 1;
    out << YAML::Value << YAML::BeginMap;
    out << YAML::Key << "PrimitiveType" << YAML::Value << primitiveType;
    out << YAML::Key << "ActionName" << YAML::Value << name;
    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;
    
    for (const auto & actionState : actionStates) { //.second is the set of ActionState
        
        std::string contSeq = "ActionState_" + std::to_string(nCont);
        out << YAML::Key << contSeq; 
        
        out << YAML::Value << YAML::BeginMap;
            //actionState.first, the jointstates map
            out << YAML::Key << "JointPos" << YAML::Value << YAML::BeginMap;
            for (const auto &joint : actionState.first) {
                out << YAML::Key << joint.first;
                out << YAML::Value << YAML::Flow << joint.second; //vector of double is emitted like Seq
            }
            out << YAML::EndMap;
            
             //actionState.second, the optional
            out << YAML::Key << "Optional" << YAML::Value << YAML::BeginMap;
                out << YAML::Key << "DepthSum" << YAML::Value << actionState.second;
            out << YAML::EndMap;
            
        out << YAML::EndMap;
        nCont++;
    }
    out << YAML::EndMap;

}

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

overridevirtual

function to fill members of the Action with infos taken from yaml files

Parameters

yamlIt

a YAML::const_iterator to the node that is loaded with YAML::LoadFile(dirPath + filename). check YamlWorker to correctly parse and emit the file

Implements ROSEE::Action.

Definition at line 182 of file ActionMultiplePinchTight.cpp.

                                                                             {
        
    std::vector <std::string> fingInvolvedVect = yamlIt->first.as <std::vector < std::string >> ();
    for (const auto &it : fingInvolvedVect) {
        fingersInvolved.insert(it);
    }

    for ( YAML::const_iterator keyValue = yamlIt->second.begin(); keyValue != yamlIt->second.end(); ++keyValue) {        
        
        std::string key = keyValue->first.as<std::string>();
        if (key.compare("JointsInvolvedCount") == 0) {
            jointsInvolvedCount = keyValue->second.as < JointsInvolvedCount > ();
            
        } else if (key.compare ("ActionName") == 0 ) {
            name = keyValue->second.as <std::string> ();
        
        } else if (key.compare ("PrimitiveType") == 0) {
            ROSEE::ActionPrimitive::Type parsedType = static_cast<ROSEE::ActionPrimitive::Type> ( 
                keyValue->second.as <unsigned int>() );
            if (parsedType != primitiveType ) {
                std::cerr << "[ERROR ActionMultPinch::" << __func__ << " parsed a type " << parsedType << 
                    " but this object has primitive type " << primitiveType << std::endl; 
                return false;
            }
            
        } else if (key.compare(0, 12, "ActionState_") == 0) { //compare 12 caracters from index 0 of key

            JointPos jointPos;
            double depthSum;
            for(YAML::const_iterator asEl = keyValue->second.begin(); asEl != keyValue->second.end(); ++asEl) {

                //asEl can be the map JointPos or the map Optional
                if (asEl->first.as<std::string>().compare ("JointPos") == 0 ) {
                    jointPos = asEl->second.as < JointPos >(); 
                    
                } else if (asEl->first.as<std::string>().compare ("Optional") == 0 ) {
                    depthSum = asEl->second["DepthSum"].as < double >();
                    
                } else {
                    //ERRROr, only JointPos and Optional at this level
                    std::cerr << "[ERROR ActionMultPinch::" << __func__ << "not know key " 
                        << asEl->first.as<std::string>() << 
                        " found in the yaml file at this level" << std::endl; 
                    return false;
                }
            }  
            actionStates.insert ( std::make_pair (jointPos, depthSum));
            
        } else {
            std::cerr << "[ERROR ActionMultPinch::" << __func__ << "not know key " << key << 
                " found in the yaml file" << std::endl; 
            return false;
        }
    }
    
    nFingersInvolved = fingersInvolved.size();
    
    return true;
}

std::vector< ROSEE::ActionMultiplePinchTight::StateWithDepth > ROSEE::ActionMultiplePinchTight::getActionStates

(

)

const

Specific get for the ActionMultiplePinchTight to return the state with the paired depthSum.

Returns

The vector (of size maxStoredActionStates) containing all the StateWithDepth objects

Definition at line 65 of file ActionMultiplePinchTight.cpp.

                                                                                                                {
    
    std::vector < ROSEE::ActionMultiplePinchTight::StateWithDepth > retVect;
    retVect.reserve ( actionStates.size() );
    
    for (auto it : actionStates ) {
        retVect.push_back(it);
    }
    
    return retVect;
    
}

std::vector< ROSEE::JointPos > ROSEE::ActionMultiplePinchTight::getAllJointPos ( ) const

overridevirtual

Return all the joint position stored.

If the concrete (derived from Action) has only one joint position info, this function is equal to getJointPos.

Returns

vector containing all the joint pos of the action

Implements ROSEE::Action.

Definition at line 52 of file ActionMultiplePinchTight.cpp.

                                                                               {
    
    std::vector < JointPos > retVect;
    retVect.reserve ( actionStates.size() );
    
    for (auto it : actionStates ) {
        retVect.push_back(it.first);
    }
    
    return retVect;
}

ROSEE::JointPos ROSEE::ActionMultiplePinchTight::getJointPos ( ) const

overridevirtual

Get the position related to this action.

Pure Virtual function: the derived class store this info differently so they are in charge of providing the read.

Returns

JointsPos the map indicating how the position of the joint

Implements ROSEE::Action.

Definition at line 39 of file ActionMultiplePinchTight.cpp.

                                                               {
    return (actionStates.begin()->first);
}

ROSEE::JointPos ROSEE::ActionMultiplePinchTight::getJointPos

(

unsigned int

index

)

const

Definition at line 43 of file ActionMultiplePinchTight.cpp.

                                                                                  {
    auto it = actionStates.begin();
    unsigned int i = 1;
    while (i < index ) {
        ++ it;
    }
    return (it->first);
}

bool ROSEE::ActionMultiplePinchTight::insertActionState	(	ROSEE::JointPos	jp,
		double	depthSum
	)

function to insert a single action in the actionStates set of possible action.

If the action is not so good (depthSum) the action is not inserted and the function return false

Parameters

JointPos	The joints position
depthSum	the sum of all depth of collisions pairs

Returns

TRUE if the action is good and is inserted in the set actionStates FALSE if the action given as argument was not good as the others in the set actionStates and the set was already full (maxStoredActionStates)

Definition at line 78 of file ActionMultiplePinchTight.cpp.

                                       {

    auto pairRet = actionStates.insert ( std::make_pair (jp, depthSum) ) ;
    
    if (! pairRet.second ) {
        //TODO print error no insertion because depth is equal... very improbable
        return false;
    }
    
    if (actionStates.size() > maxStoredActionStates) { 
        //max capacity reached, we have to delete the last one
        auto it = pairRet.first;        
        
        if ( (++it) == actionStates.end() ){
           // the new inserted is the last one and has to be erased
            actionStates.erase(pairRet.first);
            return false;
        }
        
        // the new inserted is not the last one that has to be erased
        auto lastElem = actionStates.end();
        --lastElem;
        actionStates.erase(lastElem);
    }
    
    return true;
}

void ROSEE::ActionMultiplePinchTight::print ( ) const

overridevirtual

Overridable functions, if we want to make them more action-specific.

Reimplemented from ROSEE::Action.

Definition at line 108 of file ActionMultiplePinchTight.cpp.

                                                 {
    
    std::stringstream output;
    output << "ActionName: " << name << std::endl;
    
    output << "FingersInvolved: [";
    for (auto fingName : fingersInvolved){
        output << fingName << ", " ;
    }
    output.seekp (-2, output.cur); //to remove the last comma (and space)
    output << "]" << std::endl;
    
    output << "JointsInvolvedCount: " << std::endl;;
    output << jointsInvolvedCount << std::endl;
    
    unsigned int nActState = 1;
    for (auto itemSet : actionStates) {  //the element in the set
        output << "Action_State_" << nActState << " :" << std::endl;

        output << "\t" << "JointStates:" << std::endl;
        output << itemSet.first;
        output << "\t" << "DepthSum:" <<  itemSet.second <<std::endl;
            
        nActState++;
    }
    output << std::endl;
    
    std::cout << output.str();

}

Member Data Documentation

std::set< StateWithDepth, depthComp > ROSEE::ActionMultiplePinchTight::actionStates

private

For each multiple pinch possible, we want a set of action because we want to store (in general) more possible way to do that action with that X fingers.

The pinch among X tips can theoretically be done in infinite ways, so we store the best ways found (ordering them with depthSum of fingertips compenetration)

Definition at line 105 of file ActionMultiplePinchTight.h.

---

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

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