Statistics
| Branch: | Tag: | Revision:

hlrc / client / cpp / src / MiddlewareRSB.cpp @ 38936fe1

History | View | Annotate | Download (9.401 KB)

1 0c286af0 Simon Schulz
/*
2
* This file is part of hlrc
3
*
4
* Copyright(c) sschulz <AT> techfak.uni-bielefeld.de
5
* http://opensource.cit-ec.de/projects/hlrc
6
*
7
* This file may be licensed under the terms of the
8
* GNU General Public License Version 3 (the ``GPL''),
9
* or (at your option) any later version.
10
*
11
* Software distributed under the License is distributed
12
* on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
13
* express or implied. See the GPL for the specific language
14
* governing rights and limitations.
15
*
16
* You should have received a copy of the GPL along with this
17
* program. If not, go to http://www.gnu.org/licenses/gpl.html
18
* or write to the Free Software Foundation, Inc.,
19
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20
*
21
* The development of this software was supported by the
22
* Excellence Cluster EXC 277 Cognitive Interaction Technology.
23
* The Excellence Cluster EXC 277 is a grant of the Deutsche
24
* Forschungsgemeinschaft (DFG) in the context of the German
25
* Excellence Initiative.
26
*
27
*/
28
29
#ifdef RSB_SUPPORT
30
31
#include "MiddlewareRSB.h"
32
#include <rsb/converter/Repository.h>
33
#include <rsb/converter/ProtocolBufferConverter.h>
34
35 6229bceb Simon Schulz
#include <rst/animation/EmotionExpression.pb.h>
36
#include <rst/animation/BinocularHeadGaze.pb.h>
37
#include <rst/animation/HeadAnimation.pb.h>
38 0c286af0 Simon Schulz
#include <rst/audition/Utterance.pb.h>
39 6229bceb Simon Schulz
#include <rst/audition/SoundChunk.pb.h>
40 0c286af0 Simon Schulz
#include <boost/algorithm/string.hpp>
41
#include <boost/range/algorithm_ext/erase.hpp>
42
43
using namespace std;
44
using namespace rsb;
45
using namespace rsb::patterns;
46
47
MiddlewareRSB::MiddlewareRSB(string scope) : Middleware(scope) {
48
    printf("> new MiddlewareRSB() on base scope '%s'\n",base_scope.c_str());
49
    init();
50
}
51
52
void MiddlewareRSB::init(void){
53
    printf("> MiddlewareRSB::init() registering converters\n");
54
55
    try{
56
        //converter for EmotionState
57 6229bceb Simon Schulz
        rsb::converter::Converter<string>::Ptr emotionStateConverter(new rsb::converter::ProtocolBufferConverter<rst::animation::EmotionExpression>());
58 0c286af0 Simon Schulz
        rsb::converter::converterRepository<string>()->registerConverter(emotionStateConverter);
59
60
        //converter for Utterance
61
        //rsb::converter::Converter<string>::Ptr UtteranceConverter(new rsb::converter::ProtocolBufferConverter<rst::audition::Utterance>());
62
        //rsb::converter::converterRepository<string>()->registerConverter(UtteranceConverter);
63
64
        //converter for GazeTarget
65 6229bceb Simon Schulz
        rsb::converter::Converter<string>::Ptr gazeTargetConverter(new rsb::converter::ProtocolBufferConverter<rst::animation::BinocularHeadGaze>());
66 0c286af0 Simon Schulz
        rsb::converter::converterRepository<string>()->registerConverter(gazeTargetConverter);
67
68
        //converter for MouthTarget
69 6229bceb Simon Schulz
        ///rsb::converter::Converter<string>::Ptr mouthTargetConverter(new rsb::converter::ProtocolBufferConverter<rst::robot::MouthTarget>());
70
        ///rsb::converter::converterRepository<string>()->registerConverter(mouthTargetConverter);
71 0c286af0 Simon Schulz
72
73
        //converter for Animation
74 6229bceb Simon Schulz
        rsb::converter::Converter<string>::Ptr animationConverter(new rsb::converter::ProtocolBufferConverter<rst::animation::HeadAnimation>());
75 0c286af0 Simon Schulz
        rsb::converter::converterRepository<string>()->registerConverter(animationConverter);
76
77
    }catch(std::invalid_argument e){
78
        printf("> converters already registered\n");
79
    }
80
81
    //first get a factory instance that is used to create RSB domain objects
82
    Factory &factory = getFactory();
83
84
    //get server
85
    string scope = base_scope + "/set/";
86
    hlrc_server = factory.createRemoteServer(scope);
87
88
    printf("> init done\n");
89
90
}
91
92
void MiddlewareRSB::publish_emotion(string scope_target, RobotEmotion e, bool blocking){
93 888a909b Robert Haschke
    std::shared_ptr<rst::animation::EmotionExpression> request(new rst::animation::EmotionExpression());
94 0c286af0 Simon Schulz
95
    switch(e.value){
96
        default:
97
            printf("> WANRING: invalid emotion id %d. defaulting to NEUTRAL\n",e.value);
98
            //fall through:
99
        case(RobotEmotion::NEUTRAL):
100 6229bceb Simon Schulz
            request->set_emotion(rst::animation::EmotionExpression::NEUTRAL);
101 0c286af0 Simon Schulz
            break;
102
        case(RobotEmotion::HAPPY):
103 6229bceb Simon Schulz
            request->set_emotion(rst::animation::EmotionExpression::HAPPY);
104 0c286af0 Simon Schulz
            break;
105
        case(RobotEmotion::SAD):
106 6229bceb Simon Schulz
            request->set_emotion(rst::animation::EmotionExpression::SAD);
107 0c286af0 Simon Schulz
            break;
108
        case(RobotEmotion::ANGRY):
109 6229bceb Simon Schulz
            request->set_emotion(rst::animation::EmotionExpression::ANGRY);
110 0c286af0 Simon Schulz
            break;
111
        case(RobotEmotion::SURPRISED):
112 6229bceb Simon Schulz
            request->set_emotion(rst::animation::EmotionExpression::SURPRISED);
113 0c286af0 Simon Schulz
            break;
114
        case(RobotEmotion::FEAR):
115 6229bceb Simon Schulz
            request->set_emotion(rst::animation::EmotionExpression::FEAR);
116 0c286af0 Simon Schulz
            break;
117
    }
118
119
    request->set_duration(e.time_ms);
120
121
    if (blocking){
122 6229bceb Simon Schulz
        hlrc_server->call<rst::animation::EmotionExpression>(scope_target, request);
123 0c286af0 Simon Schulz
    }else{
124 6229bceb Simon Schulz
        hlrc_server->callAsync<rst::animation::EmotionExpression>(scope_target, request);
125 0c286af0 Simon Schulz
    }
126
}
127
128
129
void MiddlewareRSB::publish_current_emotion(RobotEmotion e, bool blocking){
130
    publish_emotion("currentEmotion", e, blocking);
131
}
132
133
void MiddlewareRSB::publish_default_emotion(RobotEmotion e, bool blocking){
134
    publish_emotion("defaultEmotion", e, blocking);
135
}
136
137 6229bceb Simon Schulz
void MiddlewareRSB::publish_gaze_target(RobotGaze incoming_target, bool blocking){
138 888a909b Robert Haschke
    std::shared_ptr<rst::animation::BinocularHeadGaze> request(new rst::animation::BinocularHeadGaze ());
139 6229bceb Simon Schulz
140 888a909b Robert Haschke
    std::shared_ptr<rst::geometry::SphericalDirectionFloat> target(new rst::geometry::SphericalDirectionFloat ());
141 6229bceb Simon Schulz
    target->set_azimuth(incoming_target.pan);
142
    target->set_elevation(incoming_target.tilt);
143
    request->set_allocated_target(target.get());
144 0c286af0 Simon Schulz
145 6229bceb Simon Schulz
    request->set_eye_vergence(incoming_target.vergence);
146
147 888a909b Robert Haschke
    std::shared_ptr<rst::geometry::SphericalDirectionFloat> offset(new rst::geometry::SphericalDirectionFloat());
148 6229bceb Simon Schulz
    offset->set_azimuth(incoming_target.pan_offset);
149
    offset->set_elevation(incoming_target.tilt_offset);
150
    request->set_allocated_offset(offset.get());
151 0c286af0 Simon Schulz
152
    if (blocking){
153 6229bceb Simon Schulz
        hlrc_server->call<rst::animation::BinocularHeadGaze >("gaze", request);
154 0c286af0 Simon Schulz
    }else{
155 6229bceb Simon Schulz
        hlrc_server->callAsync<rst::animation::BinocularHeadGaze >("gaze", request);
156 0c286af0 Simon Schulz
    }
157
}
158
159 f0dcf4ca Robert Haschke
void MiddlewareRSB::publish_lookat_target(float x, float y, float z, const std::string frame_id,
160
                                          bool blocking, float roll){
161
    std::cerr << "not yet implemented" << std::endl;
162
}
163
164 0c286af0 Simon Schulz
void MiddlewareRSB::publish_mouth_target(RobotMouth target, bool blocking){
165 6229bceb Simon Schulz
/*
166 888a909b Robert Haschke
    std::shared_ptr<rst::robot::MouthTarget> request(new rst::robot::MouthTarget());
167 0c286af0 Simon Schulz

168
    request->set_position_left(  target.position_left);
169
    request->set_position_center(target.position_center);
170
    request->set_position_right( target.position_right);
171

172
    request->set_opening_left(  target.opening_left);
173
    request->set_opening_center(target.opening_center);
174
    request->set_opening_right( target.opening_right);
175

176
    if (blocking){
177
        hlrc_server->call<rst::robot::MouthTarget>("mouth", request);
178
    }else{
179
        hlrc_server->callAsync<rst::robot::MouthTarget>("mouth", request);
180
    }
181 6229bceb Simon Schulz
*/
182
    printf("> ERROR: mouth targets not yet implemented in RSB middleware!\n");
183 0c286af0 Simon Schulz
}
184
185
void MiddlewareRSB::publish_head_animation(RobotHeadAnimation a, bool blocking){
186 888a909b Robert Haschke
    std::shared_ptr<rst::animation::HeadAnimation> request(new rst::animation::HeadAnimation());
187 0c286af0 Simon Schulz
188
    switch(a.value){
189
        default:
190
            printf("> WANRING: invalid animation id %d. defaulting to IDLE",a.value);
191
            //fall through:
192
        case(RobotHeadAnimation::IDLE):
193 6229bceb Simon Schulz
            request->set_animation(rst::animation::HeadAnimation::IDLE);
194 0c286af0 Simon Schulz
            break;
195
        case(RobotHeadAnimation::HEAD_NOD):
196 6229bceb Simon Schulz
            request->set_animation(rst::animation::HeadAnimation::HEAD_NOD);
197 0c286af0 Simon Schulz
            break;
198
        case(RobotHeadAnimation::HEAD_SHAKE):
199 6229bceb Simon Schulz
            request->set_animation(rst::animation::HeadAnimation::HEAD_SHAKE);
200 0c286af0 Simon Schulz
            break;
201
        case(RobotHeadAnimation::EYEBLINK_L):
202 6229bceb Simon Schulz
            request->set_animation(rst::animation::HeadAnimation::EYEBLINK_LEFT);
203 0c286af0 Simon Schulz
            break;
204
        case(RobotHeadAnimation::EYEBLINK_R):
205 6229bceb Simon Schulz
            request->set_animation(rst::animation::HeadAnimation::EYEBLINK_RIGHT);
206 0c286af0 Simon Schulz
            break;
207
        case(RobotHeadAnimation::EYEBLINK_BOTH):
208 6229bceb Simon Schulz
            request->set_animation(rst::animation::HeadAnimation::EYEBLINK_BOTH);
209 0c286af0 Simon Schulz
            break;
210
        case(RobotHeadAnimation::EYEBROWS_RAISE):
211 6229bceb Simon Schulz
            request->set_animation(rst::animation::HeadAnimation::EYEBROWS_RAISE);
212 0c286af0 Simon Schulz
            break;
213
        case(RobotHeadAnimation::EYEBROWS_LOWER):
214 6229bceb Simon Schulz
            request->set_animation(rst::animation::HeadAnimation::EYEBROWS_LOWER);
215
            break;
216
        case(RobotHeadAnimation::ENGAGEMENT_LEFT):
217
            request->set_animation(rst::animation::HeadAnimation::ENGAGEMENT_LEFT);
218
            break;
219
        case(RobotHeadAnimation::ENGAGEMENT_RIGHT):
220
            request->set_animation(rst::animation::HeadAnimation::ENGAGEMENT_RIGHT);
221 0c286af0 Simon Schulz
            break;
222
    }
223
224
    request->set_repetitions(a.repetitions);
225 6229bceb Simon Schulz
    request->set_emphasis_scale(a.scale);
226 0c286af0 Simon Schulz
    request->set_duration_each(a.time_ms);
227
228
    if (blocking){
229 6229bceb Simon Schulz
        hlrc_server->call<rst::animation::HeadAnimation>("animation", request);
230 0c286af0 Simon Schulz
    }else{
231 6229bceb Simon Schulz
        hlrc_server->callAsync<rst::animation::HeadAnimation>("animation", request);
232 0c286af0 Simon Schulz
    }
233
}
234
235
void MiddlewareRSB::publish_speech(string text, bool blocking){
236
    //say it
237 888a909b Robert Haschke
    std::shared_ptr<std::string> request(new string(text));
238 0c286af0 Simon Schulz
239
    if (blocking){
240
        hlrc_server->call<std::string>("speech", request);
241
    }else{
242
        hlrc_server->callAsync<std::string>("speech", request);
243
    }
244
}
245
246
#endif