hlrc

		printf("       <middleware> is either ROS or RSB\n");

	RobotController* robot_controller = new RobotController("RSB", "/flobi");

		printf("> ERROR: hlrc was compiled without ROS middleware support. Please use MiddlewareRSB() instead!\n\n");

/*

 * This file is part of hlrc

 *

 * Copyright(c) sschulz <AT> techfak.uni-bielefeld.de

 * http://opensource.cit-ec.de/projects/hlrc

 *

 * This file may be licensed under the terms of the

 * GNU General Public License Version 3 (the ``GPL''),

 * or (at your option) any later version.

 *

 * Software distributed under the License is distributed

 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either

 * express or implied. See the GPL for the specific language

 * governing rights and limitations.

 *

 * You should have received a copy of the GPL along with this

 * program. If not, go to http://www.gnu.org/licenses/gpl.html

 * or write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * The development of this software was supported by the

 * Excellence Cluster EXC 277 Cognitive Interaction Technology.

 * The Excellence Cluster EXC 277 is a grant of the Deutsche

 * Forschungsgemeinschaft (DFG) in the context of the German

 * Excellence Initiative.

 *

 */

#pragma once

#include "Middleware.h"

#ifdef RSB_SUPPORT

#define BOOST_SIGNALS_NO_DEPRECATION_WARNING // mute warnings from RSB

#include <rsb/Factory.h>

#include <rsb/Informer.h>

#include <rsb/Listener.h>

#if USE_INPROTK_SYNTHESIS

#include <rst/communicationpatterns/TaskState.pb.h>

#endif

#endif

class MiddlewareRSB : public Middleware {

#ifndef RSB_SUPPORT

public:

	MiddlewareRSB(std::string scope) : Middleware(scope) {

		printf("> ERROR: hlrc was compiled without RSB middleware support. Please use MiddlewareROS() instead!\n\n");

		exit(EXIT_FAILURE);

	}

	void init(){};

	void publish_default_emotion(RobotEmotion e, bool blocking){};

	void publish_current_emotion(RobotEmotion e, bool blocking){};

	void publish_gaze_target(RobotGaze g, bool blocking){};

	void publish_lookat_target(float x, float y, float z, const std::string frame_id, bool blocking, float roll){};

	void publish_mouth_target(RobotMouth m, bool blocking){};

	void publish_head_animation(RobotHeadAnimation a, bool blocking){};

	void publish_speech(std::string text, bool blocking){};

#else

public:

	MiddlewareRSB(std::string scope);

protected:

	void init();

	void publish_current_emotion(RobotEmotion e, bool blocking);

	void publish_default_emotion(RobotEmotion e, bool blocking);

	void publish_gaze_target(RobotGaze target, bool blocking);

	void publish_lookat_target(float x, float y, float z, const std::string frame_id, bool blocking, float roll);

	void publish_mouth_target(RobotMouth target, bool blocking);

	void publish_head_animation(RobotHeadAnimation a, bool blocking);

	void publish_speech(std::string text, bool blocking);

private:

	void publish_emotion(std::string scope_target, RobotEmotion e, bool blocking);

	// rsb::patterns::RemoteServerPtr inprotk_server;

	rsb::patterns::RemoteServerPtr hlrc_server;

	// rsb::patterns::LocalServerPtr inprotk_server;

#if USE_INPROTK_SYNTHESIS

	rsb::Informer<rst::communicationpatterns::TaskState>::Ptr inprotk_informer;

	rsb::ListenerPtr inprotk_listener;

	rsb::ListenerPtr hack_listener;

	std::mutex pending_tasks_mutex;

	std::vector<std::shared_ptr<rst::communicationpatterns::TaskState> > pending_tasks;

	unsigned int say_task_active;

	unsigned int say_task_done;

	std::mutex current_saytask_mutex;

	std::string current_saytask;

	std::string get_current_saytask();

	void set_current_saytask(std::string text);

	void check_for_inprotk();

	void incoming_hack(std::shared_ptr<std::string> finished_task);

#endif

#endif

};

/*

 * This file is part of hlrc

 *

 * Copyright(c) sschulz <AT> techfak.uni-bielefeld.de

 * http://opensource.cit-ec.de/projects/hlrc

 *

 * This file may be licensed under the terms of the

 * GNU General Public License Version 3 (the ``GPL''),

 * or (at your option) any later version.

 *

 * Software distributed under the License is distributed

 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either

 * express or implied. See the GPL for the specific language

 * governing rights and limitations.

 *

 * You should have received a copy of the GPL along with this

 * program. If not, go to http://www.gnu.org/licenses/gpl.html

 * or write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * The development of this software was supported by the

 * Excellence Cluster EXC 277 Cognitive Interaction Technology.

 * The Excellence Cluster EXC 277 is a grant of the Deutsche

 * Forschungsgemeinschaft (DFG) in the context of the German

 * Excellence Initiative.

 *

 */

#ifdef RSB_SUPPORT

#include "MiddlewareRSB.h"

#include <rsb/converter/Repository.h>

#include <rsb/converter/ProtocolBufferConverter.h>

#include <rst/animation/EmotionExpression.pb.h>

#include <rst/animation/BinocularHeadGaze.pb.h>

#include <rst/animation/HeadAnimation.pb.h>

#include <rst/audition/Utterance.pb.h>

#include <rst/audition/SoundChunk.pb.h>

#include <boost/algorithm/string.hpp>

#include <boost/range/algorithm_ext/erase.hpp>

using namespace std;

using namespace rsb;

using namespace rsb::patterns;

MiddlewareRSB::MiddlewareRSB(string scope) : Middleware(scope) {

	printf("> new MiddlewareRSB() on base scope '%s'\n", base_scope.c_str());

	init();

}

void MiddlewareRSB::init(void) {

	printf("> MiddlewareRSB::init() registering converters\n");

	try {

		// converter for EmotionState

		rsb::converter::Converter<string>::Ptr emotionStateConverter(

		   new rsb::converter::ProtocolBufferConverter<rst::animation::EmotionExpression>());

		rsb::converter::converterRepository<string>()->registerConverter(emotionStateConverter);

		// converter for Utterance

		// rsb::converter::Converter<string>::Ptr UtteranceConverter(new

		// rsb::converter::ProtocolBufferConverter<rst::audition::Utterance>());

		// rsb::converter::converterRepository<string>()->registerConverter(UtteranceConverter);

		// converter for GazeTarget

		rsb::converter::Converter<string>::Ptr gazeTargetConverter(

		   new rsb::converter::ProtocolBufferConverter<rst::animation::BinocularHeadGaze>());

		rsb::converter::converterRepository<string>()->registerConverter(gazeTargetConverter);

		// converter for MouthTarget

		/// rsb::converter::Converter<string>::Ptr mouthTargetConverter(new

		/// rsb::converter::ProtocolBufferConverter<rst::robot::MouthTarget>());

		/// rsb::converter::converterRepository<string>()->registerConverter(mouthTargetConverter);

		// converter for Animation

		rsb::converter::Converter<string>::Ptr animationConverter(

		   new rsb::converter::ProtocolBufferConverter<rst::animation::HeadAnimation>());

		rsb::converter::converterRepository<string>()->registerConverter(animationConverter);

	}

	catch (std::invalid_argument e) {

		printf("> converters already registered\n");

	}

	// first get a factory instance that is used to create RSB domain objects

	Factory& factory = getFactory();

	// get server

	string scope = base_scope + "/set/";

	hlrc_server = factory.createRemoteServer(scope);

	printf("> init done\n");

}

void MiddlewareRSB::publish_emotion(string scope_target, RobotEmotion e, bool blocking) {

	std::shared_ptr<rst::animation::EmotionExpression> request(new rst::animation::EmotionExpression());

	switch (e.value) {

		default:

			printf("> WANRING: invalid emotion id %d. defaulting to NEUTRAL\n", e.value);

			// fall through:

		case (RobotEmotion::NEUTRAL):

			request->set_emotion(rst::animation::EmotionExpression::NEUTRAL);

			break;

		case (RobotEmotion::HAPPY):

			request->set_emotion(rst::animation::EmotionExpression::HAPPY);

			break;

		case (RobotEmotion::SAD):

			request->set_emotion(rst::animation::EmotionExpression::SAD);

			break;

		case (RobotEmotion::ANGRY):

			request->set_emotion(rst::animation::EmotionExpression::ANGRY);

			break;

		case (RobotEmotion::SURPRISED):

			request->set_emotion(rst::animation::EmotionExpression::SURPRISED);

			break;

		case (RobotEmotion::FEAR):

			request->set_emotion(rst::animation::EmotionExpression::FEAR);

			break;

	}

	request->set_duration(e.time_ms);

	if (blocking) {

		hlrc_server->call<rst::animation::EmotionExpression>(scope_target, request);

	}

	else {

		hlrc_server->callAsync<rst::animation::EmotionExpression>(scope_target, request);

	}

}

void MiddlewareRSB::publish_current_emotion(RobotEmotion e, bool blocking) {

	publish_emotion("currentEmotion", e, blocking);

}

void MiddlewareRSB::publish_default_emotion(RobotEmotion e, bool blocking) {

	publish_emotion("defaultEmotion", e, blocking);

}

void MiddlewareRSB::publish_gaze_target(RobotGaze incoming_target, bool blocking) {

	std::shared_ptr<rst::animation::BinocularHeadGaze> request(new rst::animation::BinocularHeadGaze());

	std::shared_ptr<rst::geometry::SphericalDirectionFloat> target(new rst::geometry::SphericalDirectionFloat());

	target->set_azimuth(incoming_target.pan);

	target->set_elevation(incoming_target.tilt);

	request->set_allocated_target(target.get());

	request->set_eye_vergence(incoming_target.vergence);

	std::shared_ptr<rst::geometry::SphericalDirectionFloat> offset(new rst::geometry::SphericalDirectionFloat());

	offset->set_azimuth(incoming_target.pan_offset);

	offset->set_elevation(incoming_target.tilt_offset);

	request->set_allocated_offset(offset.get());

	if (blocking) {

		hlrc_server->call<rst::animation::BinocularHeadGaze>("gaze", request);

	}

	else {

		hlrc_server->callAsync<rst::animation::BinocularHeadGaze>("gaze", request);

	}

}

void MiddlewareRSB::publish_lookat_target(float x, float y, float z, const std::string frame_id, bool blocking, float roll) {

	std::cerr << "not yet implemented" << std::endl;

}

void MiddlewareRSB::publish_mouth_target(RobotMouth target, bool blocking) {

	/*

	    std::shared_ptr<rst::robot::MouthTarget> request(new rst::robot::MouthTarget());

	    request->set_position_left(  target.position_left);

	    request->set_position_center(target.position_center);

	    request->set_position_right( target.position_right);

	    request->set_opening_left(  target.opening_left);

	    request->set_opening_center(target.opening_center);

	    request->set_opening_right( target.opening_right);

	    if (blocking){

	        hlrc_server->call<rst::robot::MouthTarget>("mouth", request);

	    }else{

	        hlrc_server->callAsync<rst::robot::MouthTarget>("mouth", request);

	    }

	*/

	printf("> ERROR: mouth targets not yet implemented in RSB middleware!\n");

}

void MiddlewareRSB::publish_head_animation(RobotHeadAnimation a, bool blocking) {

	std::shared_ptr<rst::animation::HeadAnimation> request(new rst::animation::HeadAnimation());

	switch (a.value) {

		default:

			printf("> WANRING: invalid animation id %d. defaulting to IDLE", a.value);

			// fall through:

		case (RobotHeadAnimation::IDLE):

			request->set_animation(rst::animation::HeadAnimation::IDLE);

			break;

		case (RobotHeadAnimation::HEAD_NOD):

			request->set_animation(rst::animation::HeadAnimation::HEAD_NOD);

			break;

		case (RobotHeadAnimation::HEAD_SHAKE):

			request->set_animation(rst::animation::HeadAnimation::HEAD_SHAKE);

			break;

		case (RobotHeadAnimation::EYEBLINK_L):

			request->set_animation(rst::animation::HeadAnimation::EYEBLINK_LEFT);

			break;

		case (RobotHeadAnimation::EYEBLINK_R):

			request->set_animation(rst::animation::HeadAnimation::EYEBLINK_RIGHT);

			break;

		case (RobotHeadAnimation::EYEBLINK_BOTH):

			request->set_animation(rst::animation::HeadAnimation::EYEBLINK_BOTH);

			break;

		case (RobotHeadAnimation::EYEBROWS_RAISE):

			request->set_animation(rst::animation::HeadAnimation::EYEBROWS_RAISE);

			break;

		case (RobotHeadAnimation::EYEBROWS_LOWER):

			request->set_animation(rst::animation::HeadAnimation::EYEBROWS_LOWER);

			break;

		case (RobotHeadAnimation::ENGAGEMENT_LEFT):

			request->set_animation(rst::animation::HeadAnimation::ENGAGEMENT_LEFT);

			break;

		case (RobotHeadAnimation::ENGAGEMENT_RIGHT):

			request->set_animation(rst::animation::HeadAnimation::ENGAGEMENT_RIGHT);

			break;

	}

	request->set_repetitions(a.repetitions);

	request->set_emphasis_scale(a.scale);

	request->set_duration_each(a.time_ms);

	if (blocking) {

		hlrc_server->call<rst::animation::HeadAnimation>("animation", request);

	}

	else {

		hlrc_server->callAsync<rst::animation::HeadAnimation>("animation", request);

	}

}

void MiddlewareRSB::publish_speech(string text, bool blocking) {

	// say it

	std::shared_ptr<std::string> request(new string(text));

	if (blocking) {

		hlrc_server->call<std::string>("speech", request);

	}

	else {

		hlrc_server->callAsync<std::string>("speech", request);

	}

}

#endif

#include "MiddlewareRSB.h"

	else if (mw_name == "RSB") {

		// intantiate RSB mw

		middleware = new MiddlewareRSB(base_scope);

	}

		printf("ERROR: invalid middleware requested (%s). supported: {ROS, RSB}\n\n", mw_name.c_str());

            <groupId>rsb</groupId>

            <artifactId>rsb</artifactId>

            <version>[0.11.0,)</version>

        </dependency>

        <dependency>

            <groupId>rsb</groupId>

            <artifactId>rst-sandbox-csra</artifactId>

            <version>0.11-SNAPSHOT</version>

        </dependency>

        <dependency>

/*

* This file is part of hlrc

*

* Copyright(c) {flier,sschulz} <AT> techfak.uni-bielefeld.de

* http://opensource.cit-ec.de/projects/hlrc

*

* This file may be licensed under the terms of the

* GNU General Public License Version 3 (the ``GPL''),

* or (at your option) any later version.

*

* Software distributed under the License is distributed

* on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either

* express or implied. See the GPL for the specific language

* governing rights and limitations.

*

* You should have received a copy of the GPL along with this

* program. If not, go to http://www.gnu.org/licenses/gpl.html

* or write to the Free Software Foundation, Inc.,

* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

*

* The development of this software was supported by the

* Excellence Cluster EXC 277 Cognitive Interaction Technology.

* The Excellence Cluster EXC 277 is a grant of the Deutsche

* Forschungsgemeinschaft (DFG) in the context of the German

* Excellence Initiative.

*

*/

package de.uni_bielefeld.cit_ec.opensource.hlrc.client;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Map;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.TimeoutException;

import java.util.logging.Level;

import java.util.logging.Logger;

import javax.sound.sampled.AudioFormat;

import javax.sound.sampled.AudioFormat.Encoding;

import rsb.Factory;

import rsb.RSBException;

import rsb.converter.DefaultConverterRepository;

import rsb.converter.ProtocolBufferConverter;

import rsb.patterns.RemoteServer;

import rst.audition.PhonemeType.Phoneme;

import rst.audition.SoundChunkType.SoundChunk;

import rst.audition.UtteranceType.Utterance;

import rst.robot.AnimationType.Animation;

import rst.robot.AnimationType.Animation.AnimationType_t;

import rst.robot.EmotionStateType.EmotionState;

import rst.robot.EmotionStateType.EmotionState.EmotionType;

import rst.robot.GazeTargetType.GazeTarget;

import com.google.protobuf.ByteString;

// Create _abstract_ middleware class and function _interface_ for 

// future integration of additional Middleware implementations...

import rsb.Factory;

import rsb.Informer;

public class MiddlewareRSB {

    final RemoteServer server;

    final String robotname;

    static Map<Emotions, EmotionType> emo_map;

    static Map<HeadAnimations, AnimationType_t> han_map;

    public class RSBInformer {

    final Factory factory;

    final Informer<Object> informer;

    public RSBInformer(String scope) throws Throwable {

        // Get a factory instance to create RSB objects.

        factory = Factory.getInstance();

        // Create an informer on scope "/exmaple/informer".

        informer = factory.createInformer(scope);

        // Activate the informer to be ready for work

        informer.activate();

    }

    public void pushMsg(){

        try {

            // Send and event using a method that accepts the data and

            // automatically creates an appropriate event internally.

            this.informer.send("TODO");

        } catch (RSBException ex) {

            Logger.getLogger(MiddlewareRSB.class.getName()).log(Level.SEVERE, null, ex);

        }

    }

    public void closeInf() throws InterruptedException {

        try {

            // As there is no explicit removal model in java, always manually

            // deactivate the informer if it is not needed anymore

            this.informer.deactivate();

        } catch (RSBException ex) {

            Logger.getLogger(MiddlewareRSB.class.getName()).log(Level.SEVERE, null, ex);

        }

    }

}

    @SuppressWarnings("unchecked")

	public MiddlewareRSB(String robotname) {

        this.robotname = robotname;

        server = Factory.getInstance().createRemoteServer(this.robotname+"/set/");

        System.out.println("--> Robot: Talking to "+this.robotname);

        try {

            server.activate();

        } catch (RSBException ex) {

            Logger.getLogger(MiddlewareRSB.class.getName()).log(Level.SEVERE, null, ex);

        }

        {

            final ProtocolBufferConverter<EmotionState> converter = new ProtocolBufferConverter<>(EmotionState.getDefaultInstance());

            DefaultConverterRepository.getDefaultConverterRepository().addConverter(converter);

        }

        {

            final ProtocolBufferConverter<GazeTarget> converter = new ProtocolBufferConverter<>(GazeTarget.getDefaultInstance());

            DefaultConverterRepository.getDefaultConverterRepository().addConverter(converter);

        }

        {

            final ProtocolBufferConverter<Animation> converter = new ProtocolBufferConverter<>(Animation.getDefaultInstance());

            DefaultConverterRepository.getDefaultConverterRepository().addConverter(converter);

        }

        {

            final ProtocolBufferConverter<Utterance> converter = new ProtocolBufferConverter<>(Utterance.getDefaultInstance());

            DefaultConverterRepository.getDefaultConverterRepository().addConverter(converter);

        }

        {

            final ProtocolBufferConverter<SoundChunk> converter = new ProtocolBufferConverter<>(SoundChunk.getDefaultInstance());

            DefaultConverterRepository.getDefaultConverterRepository().addConverter(converter);

        }

        {

            final ProtocolBufferConverter<Phoneme> converter = new ProtocolBufferConverter<>(Phoneme.getDefaultInstance());

            DefaultConverterRepository.getDefaultConverterRepository().addConverter(converter);

        }

        emo_map = new HashMap();

        emo_map.put(Emotions.SAD,       EmotionType.SAD);

        emo_map.put(Emotions.ANGRY,     EmotionType.ANGRY);

        emo_map.put(Emotions.FEAR,      EmotionType.FEAR);

        emo_map.put(Emotions.NEUTRAL,   EmotionType.NEUTRAL);

        emo_map.put(Emotions.SURPRISED, EmotionType.SURPRISED);

        emo_map.put(Emotions.HAPPY,     EmotionType.HAPPY);

        han_map = new HashMap();

        han_map.put(HeadAnimations.HEAD_NOD,       AnimationType_t.HEAD_NOD);

        han_map.put(HeadAnimations.HEAD_SHAKE,     AnimationType_t.HEAD_SHAKE);

        han_map.put(HeadAnimations.IDLE,           AnimationType_t.IDLE);

        han_map.put(HeadAnimations.EYEBLINK_R,     AnimationType_t.EYEBLINK_R);

        han_map.put(HeadAnimations.EYEBLINK_L,     AnimationType_t.EYEBLINK_L);

        han_map.put(HeadAnimations.EYEBLINK_BOTH,  AnimationType_t.EYEBLINK_BOTH);

        han_map.put(HeadAnimations.EYEBROWS_LOWER, AnimationType_t.EYEBROWS_LOWER);

        han_map.put(HeadAnimations.EYEBROWS_RAISE, AnimationType_t.EYEBROWS_RAISE);

    }

    private SoundChunk compileSoundChunk(AudioFormat audio, byte[] data) {

       SoundChunk.Builder sc = SoundChunk.newBuilder();

        ByteString bs = ByteString.copyFrom(data);

        boolean isbig = audio.isBigEndian();

        sc.setChannels(audio.getChannels());

        sc.setData(bs);

        sc.setRate((int) audio.getSampleRate());

        if (isbig) {

            sc.setEndianness(SoundChunk.EndianNess.ENDIAN_BIG);

        } else {

            sc.setEndianness(SoundChunk.EndianNess.ENDIAN_LITTLE);

        }

        sc.setSampleCount(data.length / audio.getFrameSize());

        Encoding enc = audio.getEncoding();

        if (enc.equals(Encoding.PCM_SIGNED)) {

            int size = audio.getSampleSizeInBits();

            if (size == 8) {

                sc.setSampleType(SoundChunk.SampleType.SAMPLE_S8);

            } else if (size == 16) {

                sc.setSampleType(SoundChunk.SampleType.SAMPLE_S16);

            } else if (size == 24) {

                sc.setSampleType(SoundChunk.SampleType.SAMPLE_S24);

            } else {

                System.err.println("Audio Sample Size Not Valid");

            }

        } else if (enc.equals(Encoding.PCM_UNSIGNED)) {

            int size = audio.getSampleSizeInBits();

            if (size == 8) {

                sc.setSampleType(SoundChunk.SampleType.SAMPLE_U8);

            } else if (size == 16) {

                sc.setSampleType(SoundChunk.SampleType.SAMPLE_U16);

            } else if (size == 24) {

                sc.setSampleType(SoundChunk.SampleType.SAMPLE_U24);

            } else {

                System.err.println("Audio Sample Size not valid");

                // This is too rigorous, maybe.

                // System.exit(-1);

            }

        } else {

            System.err.println("Audio Encoding is invalid");

        }

        return sc.build();

    }

    public void deactivateServer() throws InterruptedException {

        try {

            this.server.deactivate();

        } catch (RSBException ex) {

            Logger.getLogger(MiddlewareRSB.class.getName()).log(Level.SEVERE, null, ex);

        }

    }

    // OBSOLETE

    /*

     public MouthAnimation createMouthAnimationMessage(int duration, boolean active) {

     MouthAnimation.Builder ma = MouthAnimation.newBuilder();

     ma.setDuration(duration);

     ma.setActive(active);

     return ma.build();

     }

     */

    public Utterance createSetSpeak(SoundChunk soundchunck, ArrayList tuList, String text) {

        Utterance.Builder ut = Utterance.newBuilder();

        ut.setAudio(soundchunck);

        for (int i=0; i< tuList.size();i++) {

        	Phoneme.Builder ph = Phoneme.newBuilder();

        	Tuple t = (Tuple) tuList.get(i);

        	ph.setSymbol(t.s);

            ph.setDuration(t.d);

            ut.addPhonemes(i, ph);

        }

        System.out.println("Phonem count " + ut.getPhonemesCount() + " Phonem list " + ut.getPhonemesList());

        ut.setText(text);

        return ut.build();

    }

    public Animation createHeadAnimationMessage(HeadAnimations ani, int duration, int repetition, float scale) {

        Animation.Builder ha = Animation.newBuilder();

        ha.setRepetitions(repetition);

        ha.setTarget(han_map.get(ani));

        ha.setDurationEach(duration);

        ha.setScale(scale);

        return ha.build();

    }

    public EmotionState createCurrentEmotionMessage(Emotions emo, int duration) {

        EmotionState.Builder es = EmotionState.newBuilder();

        es.setDuration(duration);

        es.setValue(emo_map.get(emo));

        return es.build();

    }

    public EmotionState createDefaultEmotionMessage(Emotions emo) {

        EmotionState.Builder es = EmotionState.newBuilder();

        es.setValue(emo_map.get(emo));

        return es.build();

    }

    public GazeTarget createGazeTargetMessage(float pan, float tilt, float roll) {

        GazeTarget.Builder gt = GazeTarget.newBuilder();

        gt.setPan(pan);

        gt.setTilt(tilt);

        gt.setRoll(roll);

        return gt.build();

    }

    public void setSpeak(AudioFormat audio, byte[] bs, ArrayList tu, String text, boolean blocking) throws ExecutionException, TimeoutException {

        SoundChunk sc;

        sc = compileSoundChunk(audio, bs);

        if (blocking) {

            try {

                server.call("utterance", createSetSpeak(sc, tu, text));

                // System.out.println("Server replied: " + server.call("utterance", createSetSpeak(sc, tu)));

            } catch (RSBException ex) {

                Logger.getLogger(MiddlewareRSB.class.getName()).log(Level.SEVERE, null, ex);

            }

        } else {

            try {             

                server.callAsync("utterance", createSetSpeak(sc, tu, text));

                // System.out.println("Set Mouth Animation non-blocking, not wating for reply");

            } catch (RSBException ex) {

                Logger.getLogger(MiddlewareRSB.class.getName()).log(Level.SEVERE, null, ex);

            }

        }

    }

    public void setCurrentEmotion(Emotions emo, int duration, boolean blocking) throws ExecutionException, TimeoutException {

        try {

            if (blocking) {

                server.call("currentEmotion", createCurrentEmotionMessage(emo, duration));

                // System.out.println("Server replied: " + server.call("currentEmotion", createEmotionMessage(emo, duration)));

            } else {        

                server.callAsync("currentEmotion", createCurrentEmotionMessage(emo, duration));

                // System.out.println("Set Emotion non-blocking, not wating for reply");

            }

        } catch (RSBException ex) {

            Logger.getLogger(MiddlewareRSB.class.getName()).log(Level.SEVERE, null, ex);

        }

    }

    public void setGazeTarget(float pan, float tilt, float roll, boolean blocking) throws ExecutionException, TimeoutException {

        try {

            if (blocking) {

                server.call("gaze", createGazeTargetMessage(pan, tilt, roll));

                // System.out.println("Server replied: " + server.call("gaze", createGazeTargetMessage(pan, tilt, roll)));

            } else {               

                server.callAsync("gaze", createGazeTargetMessage(pan, tilt, roll));

                // System.out.println("Set Gaze non-blocking, not wating for reply");

            }

        } catch (RSBException ex) {

            Logger.getLogger(MiddlewareRSB.class.getName()).log(Level.SEVERE, null, ex);

        }

    }

    public void setDefaultEmotion(Emotions emo, boolean blocking) throws ExecutionException, TimeoutException {

        try {

            if (blocking) {

                server.call("defaultEmotion", createDefaultEmotionMessage(emo));

                // System.out.println("Server replied: " + server.call("defaultEmotion", createDefaultEmotionMessage(emo)));

            } else {              

                server.callAsync("defaultEmotion", createDefaultEmotionMessage(emo));

                // System.out.println("Set Default Emotion non-blocking, not wating for reply");

            }

        } catch (RSBException ex) {

            Logger.getLogger(MiddlewareRSB.class.getName()).log(Level.SEVERE, null, ex);

        }

    }

    public void setHeadAnimation(HeadAnimations ani, int duration, int repetitions, float scale, boolean blocking) throws ExecutionException, TimeoutException {

        try {

            if (blocking) {

                server.call("animation", createHeadAnimationMessage(ani, duration, repetitions, scale));

                // System.out.println("Server replied: " + server.call("animation", createHeadAnimationMessage(ani, duration, repetitions, scale)));

            } else {

                server.callAsync("animation", createHeadAnimationMessage(ani, duration, repetitions, scale));

                // System.out.println("Set Head Animation non-blocking, not wating for reply");

            }

        } catch (RSBException ex) {

            Logger.getLogger(MiddlewareRSB.class.getName()).log(Level.SEVERE, null, ex);

        }

    }

}

    public final MiddlewareRSB mw;

"""

This file is part of hlrc

Copyright(c) sschulz <AT> techfak.uni-bielefeld.de

http://opensource.cit-ec.de/projects/hlrc

This file may be licensed under the terms of the

GNU General Public License Version 3 (the ``GPL''),

or (at your option) any later version.

Software distributed under the License is distributed

on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either

express or implied. See the GPL for the specific language

governing rights and limitations.

You should have received a copy of the GPL along with this

program. If not, go to http://www.gnu.org/licenses/gpl.html

or write to the Free Software Foundation, Inc.,

51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

The development of this software was supported by the

Excellence Cluster EXC 277 Cognitive Interaction Technology.

The Excellence Cluster EXC 277 is a grant of the Deutsche

Forschungsgemeinschaft (DFG) in the context of the German

Excellence Initiative.

"""

from .Middleware import *

import errno

import rsb

import rsb.converter

import rst

import rstsandbox

from rst.animation.EmotionExpression_pb2 import EmotionExpression

from rst.animation.HeadAnimation_pb2 import HeadAnimation

from rst.animation.BinocularHeadGaze_pb2 import BinocularHeadGaze

from rst.geometry.SphericalDirectionFloat_pb2 import SphericalDirectionFloat

class MiddlewareRSB(Middleware):

    #######################################################################

    def __init__(self, scope, loglevel=logging.WARNING):

        """initialise

        :param scope: base scope we want to listen on

        """

        # init base settings

        Middleware.__init__(self, scope, loglevel)

        self.EmotionExpression_converter = None

        self.HeadAnimation_converter = None

        self.BinocularHeadGaze_converter = None

        #call mw init

        self.server = None

        self.init_middleware()

    def __del__(self):

        """destructor

        """

        self.logger.debug("destructor of MiddlewareROS called")

    #######################################################################

    def init_middleware(self):

        """initialise middleware

        """

        # mute rsb logging:

        logging.getLogger("rsb").setLevel(logging.ERROR)

        #initialise RSB stuff

        self.logger.info(

            "initialising RSB middleware connection on scope %s, registering rst converters..." % (self.base_scope))

        self.EmotionExpression_converter = rsb.converter.ProtocolBufferConverter(messageClass=EmotionExpression)

        rsb.converter.registerGlobalConverter(self.EmotionExpression_converter)

        self.HeadAnimation_converter = rsb.converter.ProtocolBufferConverter(messageClass=HeadAnimation)

        rsb.converter.registerGlobalConverter(self.HeadAnimation_converter)

        self.BinocularHeadGaze_converter = rsb.converter.ProtocolBufferConverter(messageClass=BinocularHeadGaze)

        rsb.converter.registerGlobalConverter(self.BinocularHeadGaze_converter)

        try:

            self.server = rsb.createRemoteServer(self.base_scope + '/set')

        except ValueError:

            self.logger.error("ERROR: invalid scope given. server deactivated")

            self.server.deactivate()

            sys.exit(errno.EINVAL)

    #######################################################################

    def publish_emotion(self, em_type, emotion, blocking):

        """publish an emotion via mw

        :param em_type: type of emotion (RobotEmotion::TYPE_DEFAULT or RobotEmotion::TYPE_CURRENT)

        :param emotion: emotion to set

        :param blocking: True if this call should block until execution finished on robot

        """

        # create emotion & fill it with values:

        rsb_em = EmotionExpression()

        rsb_em.emotion = self.convert_emotiontype_to_rsbval(emotion.value)

        rsb_em.duration = int(emotion.time_ms)

        # with rsb.createRemoteServer(self.base_scope + '/{current,default}Emotion') as server:

        self.logger.debug("calling the emotion rpc (%s)..." % ("BLOCKING" if blocking else "NON-BLOCKING"))

        if (blocking):

            #blocking rpc call:

            if (em_type == EmotionExpression.TYPE_DEFAULT):

                result = self.server.defaultEmotion(rsb_em)

            else:

                result = self.server.currentEmotion(rsb_em)

            self.logger.debug("server reply: '%s'" % result)

        else:

            if (em_type == EmotionExpression.TYPE_DEFAULT):

                future = self.server.defaultEmotion.async(rsb_em)

            else:

                future = self.server.currentEmotion.async(rsb_em)

            self.logger.debug("server reply: '%s'" % future)

            #we could block here for a incoming result with a timeout in s

            #print '> server reply: "%s"' % future.get(timeout = 10);

        self.logger.debug("emotion rpc done")

    def publish_head_animation(self, animation, blocking):

        """publish an head HeadAnimation via mw

        :param HeadAnimation: HeadAnimation to set

        :param blocking: True if this call should block until execution finished on robot

        """

        self.logger.debug("calling the HeadAnimation rpc (%s)..." % ("BLOCKING" if blocking else "NON-BLOCKING"))

        # create HeadAnimation & fill it with values:

        rsb_ani = HeadAnimation()

        #select ani

        rsb_ani.animation = self.convert_HeadAnimationtype_to_rsbval(animation.value)

        rsb_ani.repetitions = animation.repetitions

        rsb_ani.duration_each = animation.time_ms

        rsb_ani.emphasis_scale = animation.scale

        if blocking:

            #blocking:

            result = self.server.animation(rsb_ani)

            self.logger.debug("server reply: '%s'" % result)

        else:

            future = self.server.animation.async(rsb_ani)

            #we can block here for a incoming result with a timeout in s

            #print '> server reply: "%s"' % future.get(timeout = 10);

        self.logger.debug("HeadAnimation rpc done")

    def publish_default_emotion(self, emotion, blocking):

        self.publish_emotion(RobotEmotion.TYPE_DEFAULT, emotion, blocking)

    def publish_current_emotion(self, emotion, blocking):

        self.publish_emotion(RobotEmotion.TYPE_CURRENT, emotion, blocking)

    def publish_gaze_target(self, gaze, blocking):

        """publish a gaze target via mw

        :param gaze: gaze to set

        :param blocking: True if this call should block until execution finished on robot

        """

        self.logger.debug("calling the gaze rpc (%s)..." % ("BLOCKING" if blocking else "NON-BLOCKING"))

        # create gaze target & fill it with values:

        hg = BinocularHeadGaze()

        hg.target.elevation = gaze.tilt

        hg.target.azimuth = gaze.pan

        hg.eye_vergence = gaze.vergence

        hg.offset.elevation = gaze.tilt_offset

        hg.offset.azimuth = gaze.pan_offset

        if blocking:

            # blocking:

            result = self.server.gaze(hg)

            self.logger.debug("server reply blocking: '%s'" % result)

        else:

            future = self.server.gaze.async(hg)

            self.logger.debug("server reply non-blocking: '%s'" % future)

            # we can block here for a incoming result with a timeout in s

            #print '> server reply: "%s"' % future.get(timeout = 10);

        self.logger.debug("gaze rpc done")

    def publish_speech(self, text, blocking):

        """publish a tts request via mw

        :param text: text to synthesize and speak

        :param blocking: True if this call should block until execution finished on robot

        """

        """

        self.logger.debug("calling the speech rpc (%s)..." % ("BLOCKING" if blocking else "NON-BLOCKING"))

        if (blocking):

            # blocking:

            result = self.server.speech(text)

            self.logger.debug("server reply: '%s'" % result)

        else:

            future = self.server.speech.async(text)

            # we can block here for a incoming result with a timeout in s

            #print '> server reply: "%s"' % future.get(timeout = 10);

        self.logger.debug("speech rpc done")

        """

        print("WARNING: Not IMPLEMENTED.")

    #######################################################################

    def is_running(self):

        return True

    #######################################################################

    # some helpers

    def convert_HeadAnimationtype_to_rsbval(self, value):

        """convert RobotHeadAnimation.value to RSB HeadAnimation value

        :param value: RobotHeadAnimation.* id to convert to rsb id

        """

        # NOTE: this convertion is important as the actual integer values of

        #      thy python api and the protobuf might be different

        if value == HeadAnimation.IDLE:

            return HeadAnimation().IDLE

        elif value == HeadAnimation.HEAD_NOD:

            return HeadAnimation().HEAD_NOD

        elif (value == HeadAnimation.HEAD_SHAKE):

            return HeadAnimation().HEAD_SHAKE

        elif (value == HeadAnimation.EYEBLINK_LEFT):

            return HeadAnimation().EYEBLINK_LEFT

        elif (value == HeadAnimation.EYEBLINK_RIGHT):

            return HeadAnimation().EYEBLINK_RIGHT

        elif (value == HeadAnimation.EYEBLINK_BOTH):

            return HeadAnimation().EYEBLINK_BOTH

        elif (value == HeadAnimation.EYEBROWS_RAISE):

            return HeadAnimation().EYEBROWS_RAISE

        elif (value == HeadAnimation.EYEBROWS_LOWER):

            return HeadAnimation().EYEBROWS_LOWER

        else:

            self.logger.error("invalid HeadAnimation type %d\n" % (value))

            return HeadAnimation().NEUTRAL

    def convert_emotiontype_to_rsbval(self, value):

        """convert RobotEmotion.value to RSB HeadAnimation value

        :param value: RobotEmotion.* id to convert to rsb id

        """

        # NOTE: this convertion is important as the actual integer values of

        #      thy python api and the protobuf might be different

        if (value == RobotEmotion.NEUTRAL):

            return EmotionExpression().NEUTRAL

        elif (value == RobotEmotion.HAPPY):

            return EmotionExpression().HAPPY

        elif (value == RobotEmotion.SAD):

            return EmotionExpression().SAD

        elif (value == RobotEmotion.ANGRY):

            return EmotionExpression().ANGRY

        elif (value == RobotEmotion.SURPRISED):

            return EmotionExpression().SURPRISED

        elif (value == RobotEmotion.FEAR):

            return EmotionExpression().FEAR

        else:

            self.logger.error("invalid emotion type %d\n" % (value))

            return EmotionExpression().NEUTRAL

    """

    def publish_mouth_target(self, mouth, blocking):

        publish a mouth target via mw

        :param mouth: mouth value to set

        :param blocking: True if this call should block until execution finished on robot

        self.logger.debug("calling the mouth rpc (%s)..." % ("BLOCKING" if blocking else "NON-BLOCKING"))

        #create mouth state & fill it with values:

        rsb_mouth = MouthTarget()

        #fill proto

        rsb_mouth.opening_left   = mouth.opening_left

        rsb_mouth.opening_center = mouth.opening_center

        rsb_mouth.opening_right  = mouth.opening_right

        rsb_mouth.position_left  = mouth.position_left

        rsb_mouth.position_center = mouth.position_center

        rsb_mouth.position_right = mouth.position_right

        if (blocking):

            #blocking:

            result = self.server.mouth(rsb_mouth)

            self.logger.debug("server reply: '%s'" % result)

        else:

            future = self.server.mouth.async(rsb_mouth)

            #we can block here for a incoming result with a timeout in s

            #print '> server reply: "%s"' % future.get(timeout = 10);

        self.logger.debug("mouth rpc done")

    """

        :param mw_name: which mw to use, currentyl ROS and RSB are supported

        if (self.mw.upper() == "RSB"):

            self.logger.info("creating new middleware connection via RSB")

            try:

                from .MiddlewareRSB import MiddlewareRSB

            except ImportError as e:

                self.logger.error("failed to import RSB or the necessary data types: {}".format(e))

                sys.exit(errno.EINVAL)

            # import worked, safe to intantiate RSB mw now

            self.middleware = MiddlewareRSB(self.scope, self.loglevel)

        elif (self.mw.upper() == "ROS"):

            self.logger.error("invalid middleware requested (%s). supported: {ROS, RSB}\n\n" % (self.mw))

      printf("> ERROR: hlc is compiled without RSB support, RSB audio transport not available, defaulting to libao (default "