/ - Diff - humotion - Research for Cognitive Interaction

.gitignore
	1	*.user
	2	.user.
	3	build*

     ## Your package locations should be listed before other locations
     include_directories(BEFORE ${Boost_INCLUDE_DIRS} ${REFLEXXES_INCLUDE_DIRS})
     include_directories(BEFORE include)
     include_directories(BEFORE include/humotion)
     #make sure to use ros messages from current build
     include_directories(BEFORE ${CATKIN_DEVEL_PREFIX}/include)
     #this should be appended:
     include_directories(${catkin_INCLUDE_DIRS})
     #link_directories (${Boost_LIBRARY_DIRS} ${REFLEXXES_LIBRARY_DIRS} ${catkin_LIBRARY_DIRS})
     #####################
     # PLEASE DO NOT REMOVE THIS! This is a hack necessary for qtcreator to show cmake header files in the project view!
     file(GLOB DUMMY_HEADER_LIST RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} include/humotion/*.h  include/humotion/client/*.h  include/humotion/server/*.h srv/*.srv msg/*.msg etc/*)
     #link_directories (${Boost_LIBRARY_DIRS} ${REFLEXXES_LIBRARY_DIRS} ${catkin_LIBRARY_DIRS})
     ## Declare a cpp library
     add_library(humotion
-...
         src/server/neck_motion_generator.cpp
         src/timestamp.cpp
         src/timestamped_list.cpp
         ${DUMMY_HEADER_LIST}
+    )
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
-...
     #finally build (some) examples
     #add_subdirectory(./examples)
     #################
     ## style guide ##
     #################
     set(ENABLE_CPPLINT 1)
     include(${CMAKE_CURRENT_SOURCE_DIR}/stylecheck/CpplintWrapper.cmake)
     CPPLINT_RECURSIVE(cpplint_include
       ${CMAKE_CURRENT_SOURCE_DIR}/include
       ${CMAKE_CURRENT_SOURCE_DIR}/include
       ${CMAKE_CURRENT_BINARY_DIR}/include)
     CPPLINT_RECURSIVE(cpplint_src
       ${CMAKE_CURRENT_SOURCE_DIR}/src
       ${CMAKE_CURRENT_SOURCE_DIR}/src
       ${CMAKE_CURRENT_BINARY_DIR}/src)
     add_dependencies(humotion cpplint_src cpplint_include)
     #workaround for qtcreator ide integration. do not remove!
     file(GLOB_RECURSE NODE_DUMMY_TARGETS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.h *.cfg *.yaml *.xml *.launch)
     add_custom_target(_dummy_target SOURCES ${NODE_DUMMY_TARGETS})

     INSTALL(TARGETS ${MAIN} DESTINATION bin)
     #############
     #################
     ## style guide ##
     #############
     #################
     set(ENABLE_CPPLINT 1)
     include(${CMAKE_CURRENT_SOURCE_DIR}/../../stylecheck/CpplintWrapper.cmake)
     CPPLINT_RECURSIVE(cpplint_include

     <?xml version="1.0" encoding="UTF-8"?>
     <!DOCTYPE QtCreatorProject>
     <!-- Written by QtCreator 3.0.1, 2016-02-16T14:14:22. -->
     <!-- Written by QtCreator 3.0.1, 2016-02-18T16:12:37. -->
     <qtcreator>
      <data>
       <variable>ProjectExplorer.Project.ActiveTarget</variable>
-...
       <valuemap type="QVariantMap">
        <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Desktop</value>
        <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">Desktop</value>
        <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">{0ff36a7d-682d-4601-a9c1-275f77eefc70}</value>
        <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">{3152ed58-41d1-426c-b17f-dbe12171436a}</value>
        <value type="int" key="ProjectExplorer.Target.ActiveBuildConfiguration">0</value>
        <value type="int" key="ProjectExplorer.Target.ActiveDeployConfiguration">0</value>
        <value type="int" key="ProjectExplorer.Target.ActiveRunConfiguration">0</value>
        <valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.0">
         <value type="bool" key="CMakeProjectManager.CMakeBuildConfiguration.UseNinja">false</value>
         <value type="QString" key="CMakeProjectManager.CMakeBuildConfiguration.UserArguments">-DCMAKE_INSTALL_PREFIX=/vol/icub/sschulz/releases/roman16-humotion-nightly/</value>
         <value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">/homes/sschulz/src/flobi/humotion/examples/hum </value>
         <value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">/homes/sschulz/src/flobidev.core/humotion/examples/yarp_icub/build</value>
         <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
          <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
           <value type="QString" key="CMakeProjectManager.MakeStep.AdditionalArguments"></value>
-...
      </data>
      <data>
       <variable>ProjectExplorer.Project.Updater.EnvironmentId</variable>
       <value type="QByteArray">{44110186-3313-405d-bf42-c546b33c1fcb}</value>
       <value type="QByteArray">{ccede451-c1b6-4b92-a13d-14bd6a65dd35}</value>
      </data>
      <data>
       <variable>ProjectExplorer.Project.Updater.FileVersion</variable>

         int previous_mouth_state;
         double target_angle_previous[iCubJointInterface::ICUB_JOINT_ID_ENUM_SIZE];
         std::string scope;
         yarp::os::BufferedPort<yarp::os::Bottle> emotion_port[4];
         yarp::os::BufferedPort<yarp::os::Bottle> emotion_port;
     };
     #endif  // EXAMPLES_HUMOTION_YARP_ICUB_INCLUDE_HUMOTION_YARP_ICUB_ICUB_FACEINTERFACE_H_

     #include "humotion_yarp_icub/icub_faceinterface.h"
     #include <boost/format.hpp>
     #include <boost/lexical_cast.hpp>
     #include <algorithm>
     #include <string>
-...
         cout << "opening connection to '"<< emotion_scope << "'\n";
         bool init_ok = true;
         for (int i = 0; i < 4; i++) {
             // strange, if we use one output port only the first command is executed?! flushing issues?
             std::string emotion_port_out = "/emotionwriter" + boost::lexical_cast<std::string>(i);
             if (!emotion_port[i].open(emotion_port_out.c_str())) {
                 cerr << "ERROR: failed to open emotion port '" << emotion_port_out << "'\n";
                 init_ok = false;
+            }
             if (!Network::connect(emotion_port_out.c_str(), emotion_scope.c_str())) {
                 cerr << "ERROR: failed to connect to emotion port '" << emotion_port_out << "'\n";
                 init_ok = false;
+            }
         // open emotion port
         std::string emotion_port_out = "/emotionwriter";
         if (!emotion_port.open(emotion_port_out.c_str())) {
             cerr << "ERROR: failed to open emotion port '" << emotion_port_out << "'\n";
             init_ok = false;
+        }
         if (!Network::connect(emotion_port_out.c_str(), emotion_scope.c_str())) {
             cerr << "ERROR: failed to connect to emotion port '" << emotion_port_out << "'\n";
             init_ok = false;
+        }
         if (!init_ok) {
-...
     //! special command to set eyelid angle
     //! \param angle in degrees
     void iCubFaceInterface::set_eyelid_angle(float angle) {
         if (emotion_port[0].getOutputCount() > 0) {
         if (emotion_port.getOutputCount() > 0) {
             // try to set the value based on the upper one
             // some guesses from the sim: S30 = 0° / S40 = 10°
             int opening = (25.0 + 0.8*angle);
-...
             snprintf(buf, sizeof(buf), "S%2d", opening);
             // cout << "SETTING EYELID '" << buf << "' (" << angle << " -> " << opening << "\n";
             Bottle &cmd = emotion_port[0].prepare();
             Bottle &cmd = emotion_port.prepare();
             cmd.clear();
             cmd.addString(buf);
             emotion_port[0].writeStrict();
             // NOTE: writeStrict is important in order not to loose packets
             emotion_port.writeStrict();
         } else {
             cerr << "ERROR: no icub emotion output\n";
             exit(EXIT_FAILURE);
-...
     //! \param id {0=left, 1=right)
     //! \param angle in degrees
     void iCubFaceInterface::set_eyebrow_angle(int id, float *target_angle) {
         int port_id;
         if (id == iCubJointInterface::ICUB_ID_EYES_LEFT_BROW) {
             port_id = 1;
         } else {
             port_id = 2;
+        }
         if (emotion_port[port_id].getOutputCount() > 0) {
         if (emotion_port.getOutputCount() > 0) {
             double angle = target_angle[id];
             int icub_val = 0;
-...
                 cmd_s = "R0" + boost::lexical_cast<std::string>(icub_val);
+            }
             cout << "SETTING EYEBROW " << id << " (" << angle << " -> " << cmd_s << ")\n";
             // cout << "SETTING EYEBROW " << id << " (" << angle << " -> " << cmd_s << ")\n";
             Bottle &cmd = emotion_port[port_id].prepare();
             Bottle &cmd = emotion_port.prepare();
             cmd.clear();
             cmd.addString(cmd_s);
             emotion_port[port_id].writeStrict();
             // NOTE: writeStrict is important in order not to loose packets
             emotion_port.writeStrict();
         } else {
             cerr << "ERROR: no icub emotion output\n";
             exit(EXIT_FAILURE);
-...
         */
         // add mouth
         Bottle &cmd = emotion_port[3].prepare();
         Bottle &cmd = emotion_port.prepare();
         cmd.clear();
         cmd.addString(buf);
         emotion_port[3].writeStrict();
         // NOTE: writeStrict is important in order not to loose packets
         emotion_port.writeStrict();
     /*
         //store joint values which we do not handle on icub here:

         for (int i = ICUB_ID_NECK_TILT; i <= ICUB_ID_EYES_VERGENCE; i++) {
             set_target_in_velocitymode(i);
+        }
     /*
         // eyelids: unfortuantely the icub has only 1dof for eyelids
         // therefore we can only use an opening value
         float opening_left  = target_angle_[ICUB_ID_EYES_LEFT_LID_UPPER]
-...
         //mouth
         face_interface_->set_mouth(target_angle_);
     */
         // store joint values which we do not handle on icub here:
         double timestamp = humotion::Timestamp::now().to_seconds();
-...
         double min, max;
         int humotion_id = convert_icub_jointid_to_humotion(icub_id);
         ilimits->getLimits(icub_id, &min, &max);
         if (!ilimits->getLimits(icub_id, &min, &max)) {
             cerr << "ERROR: failed to call getLimits for icub joint " << icub_id << "\n";
             exit(EXIT_FAILURE);
+        }
         joint_min[humotion_id] = min;
         joint_max[humotion_id] = max;
+    }

     * Excellence Initiative.
     */
     #pragma once
     #include "middleware.h"
     #include <cstdio>
     #ifndef INCLUDE_HUMOTION_CLIENT_CLIENT_H_
     #define INCLUDE_HUMOTION_CLIENT_CLIENT_H_
     #include <cstdint>
     #include <cstdio>
     #include <string>
     namespace humotion{
     namespace client{
     #include "humotion/client/middleware.h"
     class Client{
     public:
     namespace humotion {
     namespace client {
     class Client {
      public:
         Client(std::string name, std::string mw);
     	~Client();
         ~Client();
         bool ok();
         void tick();
         void update_mouth_target(MouthState s, bool send=false);
         void update_gaze_target(GazeState s, bool send=false);
         void update_mouth_target(MouthState s, bool send = false);
         void update_gaze_target(GazeState s, bool send = false);
         void send_all();
     private:
      private:
         Middleware *middleware;
     };
+    }
+    }
     }  // namespace client
     }  // namespace humotion
     #endif  // INCLUDE_HUMOTION_CLIENT_CLIENT_H_

     * Excellence Initiative.
     */
     #pragma once
     #include <cstdio>
     #ifndef INCLUDE_HUMOTION_CLIENT_MIDDLEWARE_H_
     #define INCLUDE_HUMOTION_CLIENT_MIDDLEWARE_H_
     #include <cstdint>
     #include <cstdio>
     #include <string>
     #include "../mouth_state.h"
     #include "../gaze_state.h"
     namespace humotion{
     namespace client{
     #include "humotion/gaze_state.h"
     #include "humotion/mouth_state.h"
     namespace humotion {
     namespace client {
     class Middleware{
     public:
         Middleware(std::string name);
     class Middleware {
      public:
         explicit Middleware(std::string name);
         ~Middleware();
         void update_mouth_target(MouthState s, bool send);
-...
         virtual bool ok() = 0;
         virtual void tick() = 0;
     protected:
     	MouthState mouth_state;
      protected:
         MouthState mouth_state;
         GazeState gaze_state;
         std::string base_scope;
     };
+    }
+    }
     }  // namespace client
     }  // namespace humotion
     #endif  // INCLUDE_HUMOTION_CLIENT_MIDDLEWARE_H_

     * Forschungsgemeinschaft (DFG) in the context of the German
     * Excellence Initiative.
     */
     #pragma once
     #include "middleware.h"
     #include "ros/ros.h"
     #ifndef INCLUDE_HUMOTION_CLIENT_MIDDLEWARE_ROS_H_
     #define INCLUDE_HUMOTION_CLIENT_MIDDLEWARE_ROS_H_
     #include <boost/shared_ptr.hpp>
     #include <ros/ros.h>
     #include <string>
     #include "humotion/client/middleware.h"
     namespace humotion{
     namespace client{
     namespace humotion {
     namespace client {
     class MiddlewareROS : public Middleware{
     public:
         MiddlewareROS(std::string name);
     class MiddlewareROS : public Middleware {
      public:
         explicit MiddlewareROS(std::string name);
         ~MiddlewareROS();
         void send_mouth_target();
-...
         bool ok();
         void tick();
     private:
      private:
         bool tick_necessary;
         //boost::shared_ptr<ros::NodeHandle> node_handle;
         ros::Publisher mouth_target_publisher;
         ros::Publisher gaze_target_publisher;
     };
+    }
+    }
     }  // namespace client
     }  // namespace humotion
     #endif  // INCLUDE_HUMOTION_CLIENT_MIDDLEWARE_ROS_H_

     rsb support was dropped
     /*
     * This file is part of humotion
+    *
     * Copyright(c) sschulz <AT> techfak.uni-bielefeld.de
     * http://opensource.cit-ec.de/projects/humotion
+    *
     * This file may be licensed under the terms of the
     * GNU Lesser General Public License Version 3 (the ``LGPL''),
     * 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 LGPL for the specific language
     * governing rights and limitations.
+    *
     * You should have received a copy of the LGPL along with this
     * program. If not, go to http://www.gnu.org/licenses/lgpl.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.
     */
     #ifndef INCLUDE_HUMOTION_CLIENT_MIDDLEWARE_RSB_H_
     #define INCLUDE_HUMOTION_CLIENT_MIDDLEWARE_RSB_H_
     // rsb support was dropped
     #endif  // INCLUDE_HUMOTION_CLIENT_MIDDLEWARE_RSB_H_

     * Excellence Initiative.
     */
     #pragma once
     #ifndef INCLUDE_HUMOTION_GAZE_STATE_H_
     #define INCLUDE_HUMOTION_GAZE_STATE_H_
     #include <math.h>
     #include "timestamp.h"
     namespace humotion{
     class GazeState{
     public:
     #include "humotion/timestamp.h"
     namespace humotion {
     class GazeState {
      public:
             GazeState();
             ~GazeState();
             void dump();
             //pan tilt roll
             // pan tilt roll
             float pan;
             float tilt;
             float roll;
-...
             float tilt_offset;
             float roll_offset;
             //pan,tilt,roll can be relative or absolute
             // pan,tilt,roll can be relative or absolute
             int gaze_type;
             //when was this target requested?
             // when was this target requested?
             Timestamp timestamp;
             //is this relative or
             // is this relative or absolute
             enum GAZE_STATE_TYPE{
                 GAZETYPE_ABSOLUTE=0,
                 GAZETYPE_RELATIVE=1,
                 GAZETYPE_OVERRIDE=2
                 GAZETYPE_ABSOLUTE = 0,
                 GAZETYPE_RELATIVE = 1,
                 GAZETYPE_OVERRIDE = 2
             };
             //
             // eye vergence
             float vergence;
             //eyelid opening angle
             // eyelid opening angle
             float eyelid_opening_upper;
             float eyelid_opening_lower;
             //eyebrow angles
             // eyebrow angles
             float eyebrow_left;
             float eyebrow_right;
             //eyeblink request
             // eyeblink request
             int eyeblink_request_left;
             int eyeblink_request_right;
             static const int EYEBLINK_TIME_DEFAULT = 150; //ms
             static const int EYEBLINK_TIME_DEFAULT = 150;  // in ms
             float distance_pt_abs(GazeState b){
             float distance_pt_abs(GazeState b) {
                 float dist_pan = (b.pan + b.pan_offset) - (pan + pan_offset);
                 float dist_tilt = (b.tilt + b.tilt_offset) - (tilt + tilt_offset);
                 return sqrt(pow(dist_pan, 2.0) + pow(dist_tilt, 2.0));
+            }
             float distance_tilt_abs(GazeState b){
             float distance_tilt_abs(GazeState b) {
                 float dist_tilt = (b.tilt + b.tilt_offset) - (tilt + tilt_offset);
                 return fabs(dist_tilt);
+            }
             float distance_pan_abs(GazeState b){
             float distance_pan_abs(GazeState b) {
                 float dist_pan = (b.pan + b.pan_offset) - (pan + pan_offset);
                 return fabs(dist_pan);
+            }
     };
+    }
     }  // namespace humotion
     #endif  // INCLUDE_HUMOTION_GAZE_STATE_H_

     * Excellence Initiative.
     */
     #pragma once
     #ifndef INCLUDE_HUMOTION_MOUTH_STATE_H_
     #define INCLUDE_HUMOTION_MOUTH_STATE_H_
     #include <string>
     namespace humotion{
     class MouthState{
     public:
     namespace humotion {
     class MouthState {
      public:
             MouthState();
             ~MouthState();
-...
             float position_left;
             float position_center;
             float position_right;
     };
+    }
     }  // namespace humotion
     #endif  // INCLUDE_HUMOTION_MOUTH_STATE_H_

     * Excellence Initiative.
     */
     #pragma once
     #include "../gaze_state.h"
     #include "../mouth_state.h"
     #include "../timestamp.h"
     #include "motion_generator.h"
     #include "joint_interface.h"
     #ifndef INCLUDE_HUMOTION_SERVER_CONTROLLER_H_
     #define INCLUDE_HUMOTION_SERVER_CONTROLLER_H_
     namespace humotion{
     namespace server{
     #include <vector>
     class Controller{
     public:
         Controller(JointInterface *j);
     #include "humotion/gaze_state.h"
     #include "humotion/mouth_state.h"
     #include "humotion/server/joint_interface.h"
     #include "humotion/server/motion_generator.h"
     #include "humotion/timestamp.h"
     namespace humotion {
     namespace server {
     class Controller {
      public:
         explicit Controller(JointInterface *j);
         ~Controller();
         void init_motion_generators();
         void calculate_targets();
         void publish_targets();
         void set_gaze_target(GazeState s);
         void set_mouth_target(MouthState s);
         void set_activated(void);
     private:
      private:
         bool activated;
         void add_motion_generator(MotionGenerator *m);
         GazeState relative_gaze_to_absolute_gaze(GazeState relative);
-...
         double last_known_absolute_target_pan;
         double last_known_absolute_target_tilt;
         double last_known_absolute_target_roll;
     };
+    }
+    }
     }  // namespace server
     }  // namespace humotion
     #endif  // INCLUDE_HUMOTION_SERVER_CONTROLLER_H_

     * Excellence Initiative.
     */
     #pragma once
     #include "gaze_motion_generator.h"
     #include "timestamped_list.h"
     #ifndef INCLUDE_HUMOTION_SERVER_EYE_MOTION_GENERATOR_H_
     #define INCLUDE_HUMOTION_SERVER_EYE_MOTION_GENERATOR_H_
     namespace humotion{
     namespace server{
     #include "humotion/server/gaze_motion_generator.h"
     #include "humotion/timestamped_list.h"
     class EyeMotionGenerator : public GazeMotionGenerator{
     public:
         EyeMotionGenerator(JointInterface *j);
     namespace humotion {
     namespace server {
     class EyeMotionGenerator : public GazeMotionGenerator {
      public:
         explicit EyeMotionGenerator(JointInterface *j);
         ~EyeMotionGenerator();
         void calculate_targets();
-...
         static const float SACCADE_SPEED_THRESHOLD;
     private:
         void setup_eyemotion(int dof, float target, float current_position, float current_speed, Timestamp timestamp);
      private:
         void setup_eyemotion(int dof, float target, float current_position,
                              float current_velocity, Timestamp timestamp);
         TimestampedList tsl_gaze_target_pan;
         TimestampedList tsl_gaze_target_tilt;
         TimestampedList tsl_gaze_target_vergence;
     };
+    }
+    }
     }  // namespace server
     }  // namespace humotion
     #endif  // INCLUDE_HUMOTION_SERVER_EYE_MOTION_GENERATOR_H_

     * Excellence Initiative.
     */
     #pragma once
     #include "motion_generator.h"
     #ifndef INCLUDE_HUMOTION_SERVER_EYEBROW_MOTION_GENERATOR_H_
     #define INCLUDE_HUMOTION_SERVER_EYEBROW_MOTION_GENERATOR_H_
     namespace humotion{
     namespace server{
     #include "humotion/server/motion_generator.h"
     class EyebrowMotionGenerator : public MotionGenerator{
     public:
         EyebrowMotionGenerator(JointInterface *j);
     namespace humotion {
     namespace server {
     class EyebrowMotionGenerator : public MotionGenerator {
      public:
         explicit EyebrowMotionGenerator(JointInterface *j);
         ~EyebrowMotionGenerator();
         void calculate_targets();
         void publish_targets();
     private:
      private:
     };
+    }
+    }
     }  // namespace server
     }  // namespace humotion
     #endif  // INCLUDE_HUMOTION_SERVER_EYEBROW_MOTION_GENERATOR_H_

     * Excellence Initiative.
     */
     #pragma once
     #include "eye_motion_generator.h"
     #include "boost/date_time/posix_time/posix_time.hpp"
     #ifndef INCLUDE_HUMOTION_SERVER_EYELID_MOTION_GENERATOR_H_
     #define INCLUDE_HUMOTION_SERVER_EYELID_MOTION_GENERATOR_H_
     #include <boost/date_time/posix_time/posix_time.hpp>
     #include <boost/thread/thread_time.hpp>
     namespace humotion{
     namespace server{
     #include "humotion/server/eye_motion_generator.h"
     namespace humotion {
     namespace server {
     class EyelidMotionGenerator : public EyeMotionGenerator{
     public:
         EyelidMotionGenerator(JointInterface *j);
     class EyelidMotionGenerator : public EyeMotionGenerator {
      public:
         explicit EyelidMotionGenerator(JointInterface *j);
         ~EyelidMotionGenerator();
         void calculate_targets();
-...
     private:
      private:
         bool saccade_blink_active;
         bool saccade_blink_requested;
         enum SIDE_ID{
         enum SIDE_ID {
             LEFT = 0,
             RIGHT,
             SIDE_ID_SIZE
-...
         void handle_eyeblink_timeout();
         void override_lids_for_eyeblink();
         void check_for_saccade();
         void start_eyeblink(int side, int duration=EYEBLINK_DURATION_MS);
         void start_eyeblink(int side, int duration = EYEBLINK_DURATION_MS);
         void close_eyelid(int joint_id);
-...
         boost::system_time periodic_blink_start_time;
         boost::system_time eyeblink_timeout[SIDE_ID_SIZE];
         boost::system_time eyeblink_blocked_timeout;
     };
+    }
+    }
     }  // namespace server
     }  // namespace humotion
     #endif  // INCLUDE_HUMOTION_SERVER_EYELID_MOTION_GENERATOR_H_

     * Excellence Initiative.
     */
     #pragma once
     #include "reflexxes_motion_generator.h"
     #include "timestamped_list.h"
     #ifndef INCLUDE_HUMOTION_SERVER_GAZE_MOTION_GENERATOR_H_
     #define INCLUDE_HUMOTION_SERVER_GAZE_MOTION_GENERATOR_H_
     namespace humotion{
     namespace server{
     #include "humotion/server/reflexxes_motion_generator.h"
     #include "humotion/timestamped_list.h"
     class GazeMotionGenerator : public ReflexxesMotionGenerator{
     public:
     namespace humotion {
     namespace server {
     class GazeMotionGenerator : public ReflexxesMotionGenerator {
      public:
         GazeMotionGenerator(JointInterface *j, int dof, float t);
         ~GazeMotionGenerator();
-...
         static const float SACCADE_SPEED_THRESHOLD;
         static const float SACCADE_LATENCY;
     protected:
      protected:
         GazeState get_current_gaze();
         bool get_eye_saccade_active();
         bool neck_saccade_requested;
         bool neck_saccade_omr;
     private:
         //constants
      private:
         // constants
         static const float NECK_SACCADE_THRESHOLD;
         static const float EYE_SACCADE_SPEED_THRESHOLD;
         static const float OMR_LIMIT_TRIGGERS_NECK_SACCADE;
     };
+    }
+    }
     }  // namespace server
     }  // namespace humotion
     #endif  // INCLUDE_HUMOTION_SERVER_GAZE_MOTION_GENERATOR_H_

     * Excellence Initiative.
     */
     #pragma once
     #include <cstdio>
     #ifndef INCLUDE_HUMOTION_SERVER_JOINT_INTERFACE_H_
     #define INCLUDE_HUMOTION_SERVER_JOINT_INTERFACE_H_
     #include <boost/date_time/posix_time/posix_time.hpp>
     #include <boost/thread/mutex.hpp>
     #include <boost/thread/thread.hpp>
     #include <boost/thread/thread_time.hpp>
     #include <cstdint>
     #include <string>
     #include <cstdio>
     #include <map>
     #include "../timestamped_list.h"
     #include "../mouth_state.h"
     #include "../gaze_state.h"
     #include "boost/date_time/posix_time/posix_time.hpp"
     #include <boost/thread/thread_time.hpp>
     #include <boost/thread/thread.hpp>
     #include <boost/thread/mutex.hpp>
     #include <string>
     #include "humotion/gaze_state.h"
     #include "humotion/mouth_state.h"
     #include "humotion/timestamped_list.h"
     namespace humotion{
     namespace server{
     namespace humotion {
     namespace server {
     //forward declaration to solve include loop
     // forward declaration to solve include loop
     class Controller;
     class JointInterface{
     public:
     class JointInterface {
      public:
         JointInterface();
         ~JointInterface();
-...
         unsigned int get_and_clear_incoming_position_count();
         enum JOINT_ID_ENUM{
         enum JOINT_ID_ENUM {
             ZERO = 0,
             ID_LIP_LEFT_UPPER,
             ID_LIP_LEFT_LOWER,
-...
         void store_incoming_position(int joint_id, float position, Timestamp timestamp);
         void store_incoming_velocity(int joint_id, float velocity, Timestamp timestamp);
     protected:
      protected:
         virtual void enable_joint(int id) = 0;
         virtual void disable_joint(int id) = 0;
         float framerate;
-...
     private:
      private:
         float joint_target_position_[JOINT_ID_ENUM_SIZE];
         float joint_target_velocity_[JOINT_ID_ENUM_SIZE];
-...
         bool mouth_enabled;
         bool gaze_enabled;
         unsigned int incoming_position_count;
     };
+    }
+    }
     }  // namespace server
     }  // namespace humotion
     #endif  // INCLUDE_HUMOTION_SERVER_JOINT_INTERFACE_H_

     * Excellence Initiative.
     */
     #pragma once
     #include <cstdio>
     #ifndef INCLUDE_HUMOTION_SERVER_MIDDLEWARE_H_
     #define INCLUDE_HUMOTION_SERVER_MIDDLEWARE_H_
     #include <cstdint>
     #include <cstdio>
     #include <string>
     #include "../mouth_state.h"
     #include "../gaze_state.h"
     #include "controller.h"
     namespace humotion{
     namespace server{
     #include "humotion/gaze_state.h"
     #include "humotion/mouth_state.h"
     #include "humotion/server/controller.h"
     namespace humotion {
     namespace server {
     class Middleware{
     public:
     class Middleware {
      public:
         Middleware(std::string name, Controller *c);
         ~Middleware();
         virtual bool ok() = 0;
         virtual void tick() = 0;
     protected:
      protected:
         Controller *controller;
         std::string base_scope;
     };
+    }
+    }
     }  // namespace server
     }  // namespace humotion
     #endif  // INCLUDE_HUMOTION_SERVER_MIDDLEWARE_H_

     * Excellence Initiative.
     */
     #pragma once
     #include "middleware.h"
     #include "humotion/mouth.h"
     #include "humotion/gaze.h"
     #include "ros/ros.h"
     #ifndef INCLUDE_HUMOTION_SERVER_MIDDLEWARE_ROS_H_
     #define INCLUDE_HUMOTION_SERVER_MIDDLEWARE_ROS_H_
     #include <boost/shared_ptr.hpp>
     #include <ros/ros.h>
     #include <string>
     #include "humotion/gaze.h"
     #include "humotion/mouth.h"
     #include "humotion/server/middleware.h"
     namespace humotion{
     namespace server{
     namespace humotion {
     namespace server {
     class MiddlewareROS : public Middleware{
     public:
     class MiddlewareROS : public Middleware {
      public:
         MiddlewareROS(std::string name, Controller *c);
         ~MiddlewareROS();
         bool ok();
         void tick();
     private:
      private:
         bool tick_necessary;
         void incoming_mouth_target(const humotion::mouth::ConstPtr& msg);
         void incoming_gaze_target(const humotion::gaze::ConstPtr& msg);
-...
         ros::Subscriber gaze_target_subscriber;
     };
+    }
+    }
     }  // namespace server
     }  // namespace humotion
     #endif  // INCLUDE_HUMOTION_SERVER_MIDDLEWARE_ROS_H_

     dropped RSB support
     /*
     * This file is part of humotion
+    *
     * Copyright(c) sschulz <AT> techfak.uni-bielefeld.de
     * http://opensource.cit-ec.de/projects/humotion
+    *
     * This file may be licensed under the terms of the
     * GNU Lesser General Public License Version 3 (the ``LGPL''),
     * 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 LGPL for the specific language
     * governing rights and limitations.
+    *
     * You should have received a copy of the LGPL along with this
     * program. If not, go to http://www.gnu.org/licenses/lgpl.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.
     */
     #ifndef INCLUDE_HUMOTION_SERVER_MIDDLEWARE_RSB_H_
     #define INCLUDE_HUMOTION_SERVER_MIDDLEWARE_RSB_H_
     // rsb support was dropped
     #endif  // INCLUDE_HUMOTION_SERVER_MIDDLEWARE_RSB_H_

     * Excellence Initiative.
     */
     #pragma once
     #include "joint_interface.h"
     #include "boost/date_time/posix_time/posix_time.hpp"
     #ifndef INCLUDE_HUMOTION_SERVER_MOTION_GENERATOR_H_
     #define INCLUDE_HUMOTION_SERVER_MOTION_GENERATOR_H_
     #include <boost/date_time/posix_time/posix_time.hpp>
     #include <string>
     namespace humotion{
     namespace server{
     #include "humotion/server/joint_interface.h"
     namespace humotion {
     namespace server {
     class MotionGenerator{
     public:
         MotionGenerator(JointInterface *j);
     class MotionGenerator {
      public:
         explicit MotionGenerator(JointInterface *j);
         ~MotionGenerator();
         virtual void calculate_targets()=0;
         virtual void publish_targets()=0;
         virtual void calculate_targets() = 0;
         virtual void publish_targets() = 0;
         virtual void set_gaze_target(GazeState s);
         virtual void set_mouth_target(MouthState s);
     protected:
      protected:
         float get_current_position(int joint_id);
         float get_current_speed(int joint_id);
         humotion::Timestamp get_timestamped_state(int joint_id, float *position, float *velocity);
-...
         JointInterface *joint_interface;
         //GAZE:
         // gaze
         GazeState  requested_gaze_state;
         boost::system_time last_gaze_target_update;
         bool gaze_target_input_active();
         //MOUTH
         // mouth
         MouthState requested_mouth_target;
         boost::system_time last_mouth_target_update;
         bool mouth_target_input_active();
     };
+    }
+    }
     }  // namespace server
     }  // namespace humotion
     #endif  // INCLUDE_HUMOTION_SERVER_MOTION_GENERATOR_H_

     * Excellence Initiative.
     */
     #pragma once
     #include "motion_generator.h"
     #ifndef INCLUDE_HUMOTION_SERVER_MOUTH_MOTION_GENERATOR_H_
     #define INCLUDE_HUMOTION_SERVER_MOUTH_MOTION_GENERATOR_H_
     namespace humotion{
     namespace server{
     #include "humotion/server/motion_generator.h"
     class MouthMotionGenerator : public MotionGenerator{
     public:
         MouthMotionGenerator(JointInterface *j);
     namespace humotion {
     namespace server {
     class MouthMotionGenerator : public MotionGenerator {
      public:
         explicit MouthMotionGenerator(JointInterface *j);
         ~MouthMotionGenerator();
         void calculate_targets();
         void publish_targets();
     private:
      private:
         void calculate_mouth_target(int upper, int lower);
         float mouthstate_to_opening(MouthState m, int e);
         float mouthstate_to_position(MouthState m, int e);
         void update_mouth_target(int upper_id, int lower_id);
         //minimum mouth opening:
         // minimum mouth opening
         static const float MOUTH_MIN_OPENING;
     };
+    }
+    }
     }  // namespace server
     }  // namespace humotion
     #endif  // INCLUDE_HUMOTION_SERVER_MOUTH_MOTION_GENERATOR_H_

     * Excellence Initiative.
     */
     #pragma once
     #include "gaze_motion_generator.h"
     #ifndef INCLUDE_HUMOTION_SERVER_NECK_MOTION_GENERATOR_H_
     #define INCLUDE_HUMOTION_SERVER_NECK_MOTION_GENERATOR_H_
     #include "humotion/server/gaze_motion_generator.h"
     namespace humotion{
     namespace server{
     namespace humotion {
     namespace server {
     class NeckMotionGenerator : public GazeMotionGenerator {
     public:
         NeckMotionGenerator(JointInterface *j);
      public:
         explicit NeckMotionGenerator(JointInterface *j);
         ~NeckMotionGenerator();
         void calculate_targets();
         void publish_targets();
         void setup_neckmotion(int dof, float target, float current_position, float current_speed, Timestamp timestamp);
         void setup_neckmotion(int dof, float target, float current_position,
                               float current_velocity, Timestamp timestamp);
     private:
      private:
         float get_breath_offset();
         GazeState previous_neck_target;
-...
         float breath_time;
         static const float CONST_BREATH_PERIOD;
         static const float CONST_BREATH_AMPLITUDE;
     };
+    }
+    }
     }  // namespace server
     }  // namespace humotion
     #endif  // INCLUDE_HUMOTION_SERVER_NECK_MOTION_GENERATOR_H_

     * Excellence Initiative.
     */
     #pragma once
     #include "motion_generator.h"
     #ifndef INCLUDE_HUMOTION_SERVER_REFLEXXES_MOTION_GENERATOR_H_
     #define INCLUDE_HUMOTION_SERVER_REFLEXXES_MOTION_GENERATOR_H_
     #include <ReflexxesAPI.h>
     #include <RMLPositionFlags.h>
     #include <RMLPositionInputParameters.h>
     #include <RMLPositionOutputParameters.h>
     namespace humotion{
     namespace server{
     #include "humotion/server/motion_generator.h"
     namespace humotion {
     namespace server {
     class ReflexxesMotionGenerator : public MotionGenerator{
     public:
      public:
         ReflexxesMotionGenerator(JointInterface *j, int dof, float t);
         ~ReflexxesMotionGenerator();
     protected:
         void reflexxes_set_input(int dof, float target, float current_position, float current_speed, Timestamp timestamp, float max_speed, float max_accel);
      protected:
         void reflexxes_set_input(int dof, float target,
                                  float current_position, float current_velocity,
                                  Timestamp timestamp, float max_speed, float max_accel);
         void reflexxes_calculate_profile();
         //*****************************************
-...
         //*****************************************
         int dof_count;
     private:
      private:
     };
+    }
+    }
     }  // namespace server
     }  // namespace humotion
     #endif  // INCLUDE_HUMOTION_SERVER_REFLEXXES_MOTION_GENERATOR_H_

     * Excellence Initiative.
     */
     #pragma once
     #ifndef INCLUDE_HUMOTION_SERVER_SERVER_H_
     #define INCLUDE_HUMOTION_SERVER_SERVER_H_
     #include <boost/thread/thread.hpp>
     #include <ros/ros.h>
     #include "ros/ros.h"
     #include "middleware.h"
     #include "controller.h"
     #include <cstdio>
     #include <cstdint>
     #include <cstdio>
     #include <string>
     #include <boost/thread/thread.hpp>
     namespace humotion{
     namespace server{
     #include "humotion/server/controller.h"
     #include "humotion/server/middleware.h"
     namespace humotion {
     namespace server {
     class Server{
     public:
     class Server {
      public:
         Server(std::string name, std::string mw, JointInterface *_joint_interface);
     	~Server();
         ~Server();
         bool ok();
         static const float MOTION_UPDATERATE;
     private:
      private:
         void start_motion_generation_thread();
         void motion_generation_thread();
         boost::thread *motion_generation_thread_ptr;
-...
         JointInterface *joint_interface;
     };
+    }
+    }
     }  // namespace server
     }  // namespace humotion
     #endif  // INCLUDE_HUMOTION_SERVER_SERVER_H_

     * Excellence Initiative.
     */
     #pragma once
     #include <stdlib.h>
     #ifndef INCLUDE_HUMOTION_TIMESTAMP_H_
     #define INCLUDE_HUMOTION_TIMESTAMP_H_
     #include <stdio.h>
     #include <stdlib.h>
     #include <unistd.h>
     #include <string>
     namespace humotion{
     namespace humotion {
     class Timestamp{
     public:
     class Timestamp {
      public:
         Timestamp(void);
         Timestamp(uint32_t _sec, uint32_t _nsec);
         Timestamp(double dsec);
         explicit Timestamp(double dsec);
         void set(uint32_t _sec, uint32_t _nsec);
         void set(Timestamp a);
         static Timestamp now(void);
         bool is_null(void);
         double to_seconds(void);
         bool operator>  (Timestamp &cmp);
         bool operator<= (Timestamp &cmp);
         bool operator<  (Timestamp &cmp);
         bool operator>= (Timestamp &cmp);
         bool operator== (Timestamp &cmp);
         bool operator!= (Timestamp &cmp);
         bool operator>  (const Timestamp &cmp) const;
         bool operator<= (const Timestamp &cmp) const;
         bool operator<  (const Timestamp &cmp) const;
         bool operator>= (const Timestamp &cmp) const;
         bool operator== (const Timestamp &cmp) const;
         bool operator!= (const Timestamp &cmp) const;
         uint32_t sec;
         uint32_t nsec;
     };
     }  // namespace humotion
+    }
     #endif  // INCLUDE_HUMOTION_TIMESTAMP_H_

     * Excellence Initiative.
     */
     #pragma once
     #include <stdlib.h>
     #ifndef INCLUDE_HUMOTION_TIMESTAMPED_FLOAT_H_
     #define INCLUDE_HUMOTION_TIMESTAMPED_FLOAT_H_
     #include <stdio.h>

humotion

Revision 0c8d22a5