icubClient.h

Go to the documentation of this file.

/*
 * Copyright (C) 2014 WYSIWYD Consortium, European Commission FP7 Project ICT-612139
 * Authors: Stéphane Lallée
 * email:   stephane.lallee@gmail.com
 * website: https://github.com/robotology/icub-client/
 * Permission is granted to copy, distribute, and/or modify this program
 * under the terms of the GNU General Public License, version 2 or any
 * later version published by the Free Software Foundation.
 *
 * A copy of the license can be found at
 * icub-client/license/gpl.txt
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
 * Public License for more details
 */

#ifndef __ICUBCLIENT_ICUBCLIENT_H__
#define __ICUBCLIENT_ICUBCLIENT_H__

#include <iostream>
#include <iomanip>
#include <fstream>
#include <tuple>
#include <typeindex>
#include <map>
#include <list>

#include <yarp/sig/Vector.h>

namespace icubclient{
    // forward declarations
    class OPCClient;

    class SubSystem;
    class SubSystem_agentDetector;
    class SubSystem_ARE;
    class SubSystem_babbling;
    class SubSystem_IOL2OPC;
    class SubSystem_KARMA;
    class SubSystem_Recog;
    class SubSystem_Speech;
    class SubSystem_SAM;
    class SubSystem_emotion;

    class Action;
    class Agent;
    class Entity;
    class Object;

    class ICubClient
    {
    protected:
        std::map<std::string, SubSystem*>  subSystems;
        bool                               closed;
        std::list<Action*>                 actionsKnown;

        //Reachability area
        double xRangeMin, yRangeMin, zRangeMin;
        double xRangeMax, yRangeMax, zRangeMax;

        std::string robot;  // Name of robot

    public:
        template <class T>
        T* getSubSystem(const std::string &subSystemName) {
            if (subSystems.find(subSystemName) == subSystems.end())
                return nullptr;
            else
                return (T*)subSystems[subSystemName];
        }

        template <class T>
        T* getSubSystem(T) {
            for(const auto subSystem : subSystems) {
                if(std::type_index(typeid(T)) == std::type_index(typeid(subSystem))) {
                    return subSystem;
                }
            }
            return nullptr;
        }

        SubSystem_agentDetector* getAgentDetectorClient();
        SubSystem_ARE* getARE();
        SubSystem_babbling* getBabblingClient();
        SubSystem_IOL2OPC* getIOL2OPCClient();
        SubSystem_KARMA* getKARMA();
        SubSystem_Recog* getRecogClient();
        SubSystem_Speech* getSpeechClient();
        SubSystem_SAM* getSAMClient();
        SubSystem_emotion* getEmotionClient();

        OPCClient*                  opc;
        Agent*                      icubAgent;

        ICubClient(const std::string &moduleName, const std::string &context = "icubClient",
            const std::string &clientConfigFile = "client.ini", bool isRFVerbose = false);

        bool connect(const std::string &opcName = "OPC");

        bool connectOPC(const std::string &opcName = "OPC");

        bool connectSubSystems();

        void updateAgent();

        void commitAgent();

        bool home(const std::string &part = "all");

        bool release(const std::string &oLocation, const yarp::os::Bottle &options = yarp::os::Bottle());

        bool release(const yarp::sig::VectorOf<double> &target, const yarp::os::Bottle &options = yarp::os::Bottle());

        bool point(const yarp::sig::VectorOf<double> &target, const yarp::os::Bottle &options = yarp::os::Bottle());

        bool point(const double x, const double y, const double z, const yarp::os::Bottle &options = yarp::os::Bottle()) {
            yarp::sig::VectorOf<double> target(3);
            target[0] = x;
            target[1] = y;
            target[2] = z;
            return point(target, options);
        }

        bool point(const std::string &oLocation, const yarp::os::Bottle &options = yarp::os::Bottle());

        bool waving(const bool sw);

        bool push(const std::string &oLocation, const yarp::os::Bottle &options = yarp::os::Bottle());

        bool take(const std::string &oName, const yarp::os::Bottle &options = yarp::os::Bottle());


        bool pushKarmaLeft(const std::string &objName, const double &targetPosYLeft,
            const std::string &armType = "selectable",
            const yarp::os::Bottle &options = yarp::os::Bottle());

        bool pushKarmaRight(const std::string &objName, const double &targetPosYRight,
            const std::string &armType = "selectable",
            const yarp::os::Bottle &options = yarp::os::Bottle());

        bool pushKarmaFront(const std::string &objName, const double &targetPosXFront,
            const std::string &armType = "selectable",
            const yarp::os::Bottle &options = yarp::os::Bottle());

        bool pullKarmaBack(const std::string &objName, const double &targetPosXBack,
            const std::string &armType = "selectable",
            const yarp::os::Bottle &options = yarp::os::Bottle());

        bool pushKarma(const yarp::sig::VectorOf<double> &targetCenter, const double &theta, const double &radius,
            const yarp::os::Bottle &options = yarp::os::Bottle());

        bool drawKarma(const yarp::sig::VectorOf<double> &targetCenter, const double &theta,
            const double &radius, const double &dist,
            const yarp::os::Bottle &options = yarp::os::Bottle());

        bool look(const std::string &target, const yarp::os::Bottle &options = yarp::os::Bottle());

        bool look(const yarp::sig::VectorOf<double> &target, const yarp::os::Bottle &options = yarp::os::Bottle());

        bool lookAtPartner();

        bool lookAtBodypart(const std::string &sBodypartName);

        std::string getPartnerName(bool verbose = true);

        yarp::sig::VectorOf<double> getPartnerBodypartLoc(std::string sBodypartName);

        bool babbling(int jointNumber, const std::string &babblingArm, double train_dur = -1.0);

        bool babbling(const std::string &bpName, const std::string &babblingArm, double train_dur = -1.0);


        bool say(const std::string &text, bool shouldWait = true);

        bool changeName(Entity *e, const std::string &newName);

        std::tuple<std::string, double> getHighestEmotion();

        std::list<Action*> getKnownActions();

        std::list<Object*> getObjectsInSight();

        std::list<Object*> getObjectsInRange();

        bool isTargetInRange(const yarp::sig::VectorOf<double> &target) const;

        void close();

        virtual ~ICubClient();
    };
}//Namespace
#endif