/ - Diff - hlrc - Research for Cognitive Interaction

         void override_by_utterance();
         void override_by_mouth();
         humotion::GazeState soft_overblend_gaze(humotion::GazeState gaze_now,
                                                 humotion::GazeState gaze_target,
                                                 unsigned int overblend_time);
         EmotionConfig emotion_config_current;
         EmotionConfig emotion_config_default;
         humotion::MouthState mouth_state;
         humotion::GazeState gaze_state;
         boost::posix_time::ptime gaze_state_end_time;
         humotion::GazeState gaze_state_old;
         bool gaze_state_animation_restart;
         EmotionConfig *emotion_target;
         MouthConfig mouth_config;
         boost::shared_ptr<Utterance> utterance;

     class EmotionConfig{
     public:
     public:
         typedef enum{
             NEUTRAL  = 0,
-...
         EmotionConfig();
         EmotionConfig(EmotionType e);
     	~EmotionConfig();
         ~EmotionConfig();
         void set_duration(unsigned long ms);
-...
         bool is_active();
     	//override/influence the gaze state
     	// -> override neck angles (will be added to neck ptr)
     	// -> set eyelid opening (rel to moving eyeball)
     	// -> force eyebrows
     	humotion::GazeState gaze_override;
         //override/influence the gaze state
         // -> override neck angles (will be added to neck ptr)
         // -> set eyelid opening (rel to moving eyeball)
         // -> force eyebrows
         humotion::GazeState gaze_override;
     	//override mouth
     	humotion::MouthState mouth_override;
         //override mouth
         humotion::MouthState mouth_override;
         //overblend time
         unsigned int overblend_time_ms;
     private:
          boost::system_time end_time;
         boost::system_time end_time;
     };

         EmotionConfig::EmotionType value;
         unsigned int duration;
         unsigned int overblend_time_ms;
     };

     using namespace boost;
     using namespace std;
     Arbiter::Arbiter(std::string audio_output){
         //initialize audio player:
         if (iequals(audio_output, "none")){
-...
         emotion_config_current.set_duration(2000);
         emotion_config_default.init_neutral();
         gaze_state_animation_restart = true;
         emotion_target = &emotion_config_default;
         utterance = boost::shared_ptr<Utterance>(new Utterance());
+    }
-...
         //update our config, ignore duration as this is the default emotion
         emotion_config_default.select_config(e.value);
         emotion_target = &emotion_config_default;
         gaze_state_animation_restart = true;
         printf("> stored default emotion\n");
+    }
-...
         emotion_config_current.select_config(e.value);
         emotion_config_current.set_duration(e.duration);
         emotion_target = &emotion_config_current;
         gaze_state_animation_restart = true;
         printf("> stored current emotion (val=%d, duration = %dms)\n",e.value, e.duration);
+    }
-...
+    }
     void Arbiter::override_by_emotion(){
         if (emotion_target == NULL) {
             return;
+        }
         //lock access
         mutex::scoped_lock scoped_lock1(emotion_config_default_mutex);
         mutex::scoped_lock scoped_lock2(emotion_config_current_mutex);
         EmotionConfig *emotion_target = &emotion_config_default;
         //which emotion is active?
         if (emotion_config_current.is_active()){
             //current emotion is not timed out, override default
             emotion_target = &emotion_config_current;
         // did the current emotion time out?
         if (!emotion_target->is_active()){
             // revert to default:
             emotion_target = &emotion_config_default;
             // trigger soft fade
             gaze_state_animation_restart = true;
+        }
         //emotions will set the mouth state here (will be overwritten by speak)
         mouth_state = emotion_target->mouth_override;
         //mouth_state = ...
         //emotions will add an offset to the gaze state:
         //pan,tilt,roll will be overwritten by override_by_gaze() we only keep the offset values from this!
         //FIXME: change to eyelid opening  upper/lower once humotion supports it
         //eyebrow angles come from this
         gaze_state = emotion_target->gaze_override;
         humotion::GazeState gaze_state_target = emotion_target->gaze_override;
         // apply a soft overblending to the new gaze target
         gaze_state = soft_overblend_gaze(gaze_state, gaze_state_target, emotion_target->overblend_time_ms);
         //gaze_state.dump();
         //IMPORTANT: clear request from emotion target:
         emotion_target->gaze_override.eyeblink_request_left = 0;
         emotion_target->gaze_override.eyeblink_request_right = 0;
+    }
     humotion::GazeState Arbiter::soft_overblend_gaze(humotion::GazeState gaze_now,
                                                      humotion::GazeState gaze_target,
                                                      unsigned int overblend_time) {
         humotion::GazeState result = gaze_now;
         result.eyeblink_request_left = 0;
         result.eyeblink_request_right = 0;
         if (gaze_state_animation_restart) {
             // new incoming target, set up soft fade:
             gaze_state_old = gaze_state;
             gaze_state_end_time = get_system_time() + boost::posix_time::milliseconds(overblend_time);
             gaze_state_animation_restart = false;
+        }
         // do smooth overblend, all targets should be reached at gaze_state_end_time
         boost::posix_time::time_duration tdiff = gaze_state_end_time - get_system_time();
         if (tdiff.is_negative()) {
             // animation is done, exit now
             return result;
         } else {
             // do smooth animation
             double diff_ms = tdiff.total_milliseconds();
             double tp = 1.0 - diff_ms / static_cast<double>(overblend_time);
             result.pan_offset = gaze_state_old.pan_offset + tp * (gaze_target.pan_offset - gaze_state_old.pan_offset);
             result.tilt_offset = gaze_state_old.tilt_offset + tp * (gaze_target.tilt_offset - gaze_state_old.tilt_offset);
             result.roll_offset = gaze_state_old.roll_offset + tp * (gaze_target.roll_offset - gaze_state_old.roll_offset);
             result.eyelid_opening_lower = gaze_state_old.eyelid_opening_lower + tp * (gaze_target.eyelid_opening_lower - gaze_state_old.eyelid_opening_lower);
             result.eyelid_opening_upper = gaze_state_old.eyelid_opening_upper + tp * (gaze_target.eyelid_opening_upper - gaze_state_old.eyelid_opening_upper);
             result.eyebrow_left = gaze_state_old.eyebrow_left + tp * (gaze_target.eyebrow_left - gaze_state_old.eyebrow_left);
             result.eyebrow_right = gaze_state_old.eyebrow_right + tp * (gaze_target.eyebrow_right - gaze_state_old.eyebrow_right);
+        }
         return result;
+    }

+    }
     void EmotionConfig::select_config(EmotionType e){
         // default overblend time
         overblend_time_ms = 500;
         switch((int) e){
             default:
             case(NEUTRAL): init_neutral(); break;
-...
     void EmotionConfig::init_sad(){
         gaze_override.pan_offset = 0.0;
         gaze_override.tilt_offset = -3.0;
         gaze_override.tilt_offset = -13.0;
         gaze_override.roll_offset = -3.0;
         gaze_override.gaze_type = humotion::GazeState::GAZETYPE_ABSOLUTE; //GAZETYPE_OVERRIDE;

     EmotionState::EmotionState(){
         value = EmotionConfig::NEUTRAL;
     	duration = 0;
         duration = 0;
+    }
     EmotionState::~EmotionState(){

hlrc

Revision efbcb710