ROSEE Namespace Reference

Namespaces
	Utils

Classes
class	Action
	The pure virtual class representing an Action. More...
class	ActionComposed
	A ActionComposed, which is formed by one or more Primitives (or even other composed). More...
class	ActionGeneric
	Class to handle a generic, simple action. More...
class	ActionMultiplePinchTight
	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...
class	ActionPinchGeneric
	A base virtual class for the PinchTight and PinchLoose classes. More...
class	ActionPinchLoose
	The action of pinch with two tips. More...
class	ActionPinchTight
	The action of pinch with two tips. More...
class	ActionPrimitive
	Virtual class, Base of all the primitive actions. More...
class	ActionSingleJointMultipleTips
	Primitive which indicate a motion of n fingers moving ONLY ONE joint. More...
class	ActionTimed
	An action composed by other ones that must be executed one after other with some wait time (also 0) in between. More...
class	ActionTrig
	The action of moving some joints (see later) of a single finger in a full clousure position towards the palm. More...
class	DummyHal
	Class representing an end-effector. More...
class	EEHal
	Class representing an end-effector. More...
class	EEInterface
	Class representing and End-Effector. More...
class	FindActions
	Class to check which fingertips collide (for the pinch action at the moment) More...
class	MapActionHandler
class	Parser
	Class responsible for parsing the YAML file providing the URDF, SRDF, the EE-HAL library implementation and the EEInterface. More...
class	ParserMoveIt
	class to parse urdf and srdf with moveit classes and to give information about the model parsed More...
class	RosActionServer
class	RosServiceHandler
class	UniversalRosEndEffectorExecutor
	Class representing the ROS executor implementing the unviversal ROS EE concept. More...
class	XBot2Hal
	Concrete class which communicate directly with ROS topics. More...
class	YamlWorker

Typedefs
typedef std::map< std::string, std::vector< double > >	JointPos
	The map to describe the position of all actuated joints. More...
typedef std::map< std::string, unsigned int >	JointsInvolvedCount
	The map to describe, how many times a joint is set by the action. More...

Functions
std::ostream &	operator<< (std::ostream &output, const JointPos jp)
	operator overload for JointPos so it is easier to print More...
JointPos	operator* (double multiplier, JointPos jp)
JointPos	operator* (JointPos jp, double multiplier)
JointPos &	operator*= (JointPos &jp, double multiplier)
JointPos	operator+ (JointPos jp1, JointPos jp2)
JointPos &	operator+= (JointPos &jp1, ROSEE::JointPos jp2)
std::ostream &	operator<< (std::ostream &output, const JointsInvolvedCount jic)
std::ostream &	operator<< (std::ostream &out, const ROSEE::Action::Type type)
	To print the action type enum as the real name (eg primitive) and not as the enum number REmember to add here if new type are implemented. More...

Typedef Documentation

typedef std::map<std::string, std::vector <double> > ROSEE::JointPos

The map to describe the position of all actuated joints.

The key is the name of the string, the value is a vector of joint positions (because in general a joint can have more DOFs

Definition at line 40 of file Action.h.

typedef std::map<std::string, unsigned int> ROSEE::JointsInvolvedCount

The map to describe, how many times a joint is set by the action.

An ActionPrimitive and an ActionComposed (indipendent) have as values only 0 or 1. ActionComposed (not independet) can have values > 1. This map is also useful to understand if a joint is used or not by the action (0 == not used) so we can control only the necessary joints.

Definition at line 63 of file Action.h.

Function Documentation

ROSEE::JointPos ROSEE::operator*	(	double	multiplier,
		ROSEE::JointPos	jp
	)

Definition at line 36 of file Action.cpp.

                                                                      {
    
    return jp *= multiplier;
}

ROSEE::JointPos ROSEE::operator*	(	ROSEE::JointPos	jp,
		double	multiplier
	)

Definition at line 41 of file Action.cpp.

                                                                       {
    
    return jp *= multiplier;
}

ROSEE::JointPos & ROSEE::operator*=	(	ROSEE::JointPos &	jp,
		double	multiplier
	)

Definition at line 46 of file Action.cpp.

                                                                        {
    
    for ( auto &jsEl : jp) {
        for (int i = 0; i< jsEl.second.size(); i++) {
            jsEl.second.at(i) *= multiplier;
        }
    }
    
    return jp;
}

ROSEE::JointPos ROSEE::operator+	(	ROSEE::JointPos	jp1,
		ROSEE::JointPos	jp2
	)

Definition at line 57 of file Action.cpp.

                                                                      {
    
    return jp1 += jp2;
}

ROSEE::JointPos & ROSEE::operator+=	(	ROSEE::JointPos &	jp1,
		ROSEE::JointPos	jp2
	)

Definition at line 62 of file Action.cpp.

                                                                        {
    
    if ( ! ROSEE::Utils::keys_equal(jp1, jp2) ) {
        throw ROSEE::Utils::DifferentKeysException<ROSEE::JointPos, ROSEE::JointPos>(&jp1, &jp2);
    }
    
    for (auto &jsEl : jp1) {
        if (jsEl.second.size() != jp2.at(jsEl.first).size() ) {
            throw "Dofs not same";
        }

        for (int i = 0; i < jsEl.second.size(); i++) {
            jsEl.second.at(i) += jp2.at(jsEl.first).at(i); 
        }
    }
    
    return jp1;
}

std::ostream & ROSEE::operator<<	(	std::ostream &	output,
		const JointPos	jp
	)

operator overload for JointPos so it is easier to print

Definition at line 24 of file Action.cpp.

                                                                          {
    for (const auto &jsEl : jp) {
        output << "\t\t"<<jsEl.first << " : "; //joint name
        for(const auto &jValue : jsEl.second){
            output << jValue << ", "; //joint position (vector because can have multiple dof)
        }
        output.seekp (-2, output.cur); //to remove the last comma (and space)
        output << std::endl;       
    }
    return output;
}

std::ostream & ROSEE::operator<<	(	std::ostream &	output,
		const JointsInvolvedCount	jic
	)

Definition at line 81 of file Action.cpp.

                                                                                      {
    for (const auto &jicEl : jic) {
        output << "\t"<< jicEl.first << " : " << jicEl.second;
        output << std::endl;       
    }
    return output;
}

std::ostream & ROSEE::operator<<	(	std::ostream &	out,
		const ROSEE::Action::Type	type
	)

To print the action type enum as the real name (eg primitive) and not as the enum number REmember to add here if new type are implemented.

Definition at line 89 of file Action.cpp.

                                                                        {
    
        const char* s = 0;
#define PROCESS_VAL(p) case(p): s = #p; break;
    switch(type){
        PROCESS_VAL(ROSEE::Action::Type::Primitive);     
        PROCESS_VAL(ROSEE::Action::Type::Generic);     
        PROCESS_VAL(ROSEE::Action::Type::Composed);
        PROCESS_VAL(ROSEE::Action::Type::Timed);
        PROCESS_VAL(ROSEE::Action::Type::None);
    }
#undef PROCESS_VAL

    return out << s;
}