hlrc

hlrc_client/hlrc_play_animation.py

hlrc_client/hlrc_set_emotion.py

hlrc_client/hlrc_speak_utterance.py

		#store scope

		if (mw_name.upper() == "RSB"):

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

		elif (mw_name.upper() == "ROS"):

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

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

	def get_gaze_target(self):

		result = self.middleware.get_gaze_target()

		self.logger.debug("get_gaze_target() returned %s" % (result))

		return self.middleware.get_gaze_target()

#!/usr/bin/python

#PYTHONPATH="/opt/ros/groovy/lib/python2.7/dist-packages:/vol/csra/releases/nightly/lib/python2.7/:/vol/csra/releases/nightly/lib/python2.7/site-packages/

import sys

import logging

import errno

try:

    import rsb

    import rsb.converter

    import rst

    import rstsandbox

    from rst.robot.Animation_pb2 import Animation

except ImportError as exception:

    sys.stderr.write("ImportError: {}\n> HINT: try to export PYTHONPATH=$PYTHONPATH:$YOUR_PREFIX/lib/python2.7/site-packages/\n\n".format(exception))

    sys.exit(errno.ENOPKG)

class hlrc_animation():

    def __init__(self, _base_scope):

        #print "> registering rst converter"

        converter = rsb.converter.ProtocolBufferConverter(messageClass = Animation)

        rsb.converter.registerGlobalConverter(converter)

        self.server = None	

        self.set_scope(_base_scope);

    def __del__(self):

        if (not self.server is None):

            self.server.deactivate()

    def set_scope(self, scope):

        self.base_scope = str(scope) #NOTE: str() is important here, scope is a qstring (?) and gets deleted during call

        print "> setting scope to '%s'" % self.base_scope

	if (not self.server is None):

            self.server.deactivate()

	try:

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

        except ValueError:

            print "> invalid scope given. server deactivated"

            self.server.deactivate()

    def trigger_animation(self, ani_id, repetitions, duration_each, scale, blocking):

        if (self.server is None):

            print("> invalid server")

            return

        #create animation & fill it with values:

        ani = Animation()

        #select ani

        ani.target = ani_id

        ani.repetitions = repetitions

        ani.duration_each = duration_each

        ani.scale       = scale

        if (blocking):

            #blocking:

            print "> calling the animation rpc (blocking until we finished talking)..."

            print '> server reply: "%s"' % self.server.animation(ani)

        else:

            print "> calling the animation rpc (NON-BLOCKING)..."

            return self.server.animation.async(ani)

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

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

        print "> blocking call done"

def main():

    if (len(sys.argv) != 5):

        print "> usage: %s <base scope> <animation id> <dur each> <repetitions>\n>     example: %s /flobi1 1 1000 1" % (sys.argv[0] , sys.argv[0])

        sys.exit(0)

    # Pacify logger.

    #logging.basicConfig()

    scope  = sys.argv[1]

    ani_id = int(sys.argv[2])

    dur    = int(sys.argv[3])

    rep    = int(sys.argv[4])

    scale  = 1.0

    hani = hlrc_animation(scope)

    hani.trigger_animation(ani_id, rep, dur, scale, 1)

if __name__ == '__main__':

    main()

#!/usr/bin/python

#PYTHONPATH="/opt/ros/groovy/lib/python2.7/dist-packages:/vol/csra/releases/nightly/lib/python2.7/:/vol/csra/releases/nightly/lib/python2.7/site-packages/

import sys

import logging

import errno

try:

    import rsb

    import rsb.converter

    import rst

    import rstsandbox

    from rst.robot.EmotionState_pb2 import EmotionState

except ImportError as exception:

    sys.stderr.write("ImportError: {}\n> HINT: try to export PYTHONPATH=$PYTHONPATH:$YOUR_PREFIX/lib/python2.7/site-packages/\n\n".format(exception))

    sys.exit(errno.ENOPKG)

class hlrc_emotion():

    def __init__(self, _base_scope):

        #print "> registering rst converter"

        converter = rsb.converter.ProtocolBufferConverter(messageClass = EmotionState)

        rsb.converter.registerGlobalConverter(converter)

	self.set_scope( _base_scope);

    def set_scope(self, scope):

        self.base_scope = str(scope) #NOTE: str() is important here, scope is a qstring (?) and gets deleted during call

        print "> setting scope to '%s'" % self.base_scope

        try:

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

        except ValueError:

            print "> invalid scope given. server deactivated"

            self.server.deactivate()

    def set_emotion(self, emotion_id, duration_each, blocking):

        if (self.server is None):

            print("> invalid server")

            return

        #create emotion & fill it with values:

        em = EmotionState()

        #select ani

        em.value    = emotion_id

        em.duration = duration_each

        with rsb.createRemoteServer(self.base_scope + '/set') as server:

            if (blocking):

                #blocking:

                print "> calling the emotion rpc (blocking until we finished talking)..."

                print '> server reply: "%s"' % server.currentEmotion(em)

            else:

               print "> calling the animation rpc (NON-BLOCKING)..."

               future = server.currentEmotion.async(em)

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

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

        print "> done"

def main():

    if (len(sys.argv) != 4):

        print "> usage: %s <base scope> <emotion id> <duration>\n>     example: %s /flobi1 1 1000" % (sys.argv[0] , sys.argv[0])

        sys.exit(0)

    # Pacify logger.

    #logging.basicConfig()

    em_id = int(sys.argv[2])

    dur    = int(sys.argv[3])

    base   = sys.argv[1]

    hlrc_emotion(base).set_emotion(em_id, dur, 1)

if __name__ == '__main__':

    main()

#!/usr/bin/python

#PYTHONPATH="/opt/ros/groovy/lib/python2.7/dist-packages:/vol/csra/releases/nightly/lib/python2.7/:/vol/csra/releases/nightly/lib/python2.7/site-packages/

import sys

import wave

from textgrid_hlc import *

import logging

import errno

import os.path

try:

    import rsb

    import rsb.converter

    import rst

    import rstsandbox

    from rst.audition.Utterance_pb2 import Utterance

    from rst.audition.SoundChunk_pb2 import SoundChunk

except ImportError as exception:

    sys.stderr.write("ImportError: {}\n> HINT: try to export PYTHONPATH=$PYTHONPATH:$YOUR_PREFIX/lib/python2.7/site-packages/\n\n".format(exception))

    sys.exit(errno.ENOPKG)

class hlrc_utterance():

    def __init__(self, _base_scope):

        #print "> registering rst converter"

        converter = rsb.converter.ProtocolBufferConverter(messageClass = Utterance)

        rsb.converter.registerGlobalConverter(converter)

	self.set_scope(_base_scope)

    def set_scope(self, scope):

        self.base_scope = str(scope) #NOTE: str() is important here, scope is a qstring (?) and gets deleted during call

        print "> setting scope to '%s'" % self.base_scope

        try:

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

        except ValueError:

            print "> invalid scope given. server deactivated"

            self.server.deactivate()

    def trigger_utterance(self, filename_praat, filename_wav, blocking):

        if (self.server is None):

            print("> invalid server")

            return

        if (not os.path.isfile(filename_praat)):

            print "can not open file '%s'" % (filename_praat)

            return 0

        if (not os.path.isfile(filename_wav)):

            print "can not open file '%s'" % (filename_wav)

            return 0

        print "> reading wave file '%s'" % (filename_wav)

        wav = wave.open(filename_wav, "r")

        print "> parsing praat file '%s'" % (filename_praat)

        tgrid = TextGrid.load(filename_praat)

        #create utterance & fill it with values:

        ut = Utterance()

        #textual description of audio file

        ut.text = filename_praat

        ut.audio.data = wav.readframes(-1)

        ut.audio.sample_count = wav.getnframes()

        ut.audio.channels = wav.getnchannels()

        ut.audio.rate = wav.getframerate()

        if (wav.getsampwidth() == 1):

            ut.audio.sample_type = SoundChunk.SAMPLE_U8

        elif (wav.getsampwidth() == 2):

            ut.audio.sample_type = SoundChunk.SAMPLE_S16

        else:

            print "> invalid sample type. py doc says wave files are either u8 or s16"

            exit(0)

        #wave spec says always little endian

        ut.audio.endianness = SoundChunk.ENDIAN_LITTLE

        print "> filling phones with data from praat"

        for tier in tgrid.tiers:

            idx = (tgrid.tiers.index(tier)) + 1

            transcript = tier.simple_transcript

            for (xmin, xmax, utt) in transcript:

                phoneme = ut.phonemes.add()

                phoneme.symbol = utt

                phoneme.duration = int(1000.0*(float(xmax)-float(xmin)))

        with rsb.createRemoteServer(self.base_scope + '/set') as server:

            if (blocking):

                #blocking:

                print "> calling the utterance rpc (blocking until we finished talking)..."

                print '> server reply: "%s"' % server.utterance(ut)

            else:

               print "> calling the utterance rpc (NON-BLOCKING)..."

               future = server.utterance.async(ut)

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

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

        print "> done"

        return 1

def main():

    # Pacify logger.

    #logging.basicConfig()

    if (len(sys.argv) != 4):

        print "> usage: %s <base_scope> file.praat file.wav\n>     example: %s /flobi1 hello.praat hello.wav" % (sys.argv[0] , sys.argv[0])

        sys.exit(0)

    filename_praat = sys.argv[2]

    filename_wav = sys.argv[3]

    base = sys.argv[1]

    hlc = hlrc_utterance(base)

    hlc.trigger_utterance(filename_praat, filename_wav, 1)

if __name__ == '__main__':

    main()