CameraTrajectory.h

00001 #ifndef _ROS_view_controller_msgs_CameraTrajectory_h
00002 #define _ROS_view_controller_msgs_CameraTrajectory_h
00003 
00004 #include <stdint.h>
00005 #include <string.h>
00006 #include <stdlib.h>
00007 #include "ros/msg.h"
00008 #include "view_controller_msgs/CameraMovement.h"
00009 
00010 namespace view_controller_msgs
00011 {
00012 
00013   class CameraTrajectory : public ros::Msg
00014   {
00015     public:
00016       uint32_t trajectory_length;
00017       typedef view_controller_msgs::CameraMovement _trajectory_type;
00018       _trajectory_type st_trajectory;
00019       _trajectory_type * trajectory;
00020       typedef const char* _target_frame_type;
00021       _target_frame_type target_frame;
00022       typedef bool _allow_free_yaw_axis_type;
00023       _allow_free_yaw_axis_type allow_free_yaw_axis;
00024       typedef uint8_t _mouse_interaction_mode_type;
00025       _mouse_interaction_mode_type mouse_interaction_mode;
00026       typedef bool _interaction_disabled_type;
00027       _interaction_disabled_type interaction_disabled;
00028       typedef bool _render_frame_by_frame_type;
00029       _render_frame_by_frame_type render_frame_by_frame;
00030       typedef int8_t _frames_per_second_type;
00031       _frames_per_second_type frames_per_second;
00032       enum { NO_CHANGE =  0  };
00033       enum { ORBIT =  1  };
00034       enum { FPS =  2  };
00035 
00036     CameraTrajectory():
00037       trajectory_length(0), trajectory(NULL),
00038       target_frame(""),
00039       allow_free_yaw_axis(0),
00040       mouse_interaction_mode(0),
00041       interaction_disabled(0),
00042       render_frame_by_frame(0),
00043       frames_per_second(0)
00044     {
00045     }
00046 
00047     virtual int serialize(unsigned char *outbuffer) const
00048     {
00049       int offset = 0;
00050       *(outbuffer + offset + 0) = (this->trajectory_length >> (8 * 0)) & 0xFF;
00051       *(outbuffer + offset + 1) = (this->trajectory_length >> (8 * 1)) & 0xFF;
00052       *(outbuffer + offset + 2) = (this->trajectory_length >> (8 * 2)) & 0xFF;
00053       *(outbuffer + offset + 3) = (this->trajectory_length >> (8 * 3)) & 0xFF;
00054       offset += sizeof(this->trajectory_length);
00055       for( uint32_t i = 0; i < trajectory_length; i++){
00056       offset += this->trajectory[i].serialize(outbuffer + offset);
00057       }
00058       uint32_t length_target_frame = strlen(this->target_frame);
00059       varToArr(outbuffer + offset, length_target_frame);
00060       offset += 4;
00061       memcpy(outbuffer + offset, this->target_frame, length_target_frame);
00062       offset += length_target_frame;
00063       union {
00064         bool real;
00065         uint8_t base;
00066       } u_allow_free_yaw_axis;
00067       u_allow_free_yaw_axis.real = this->allow_free_yaw_axis;
00068       *(outbuffer + offset + 0) = (u_allow_free_yaw_axis.base >> (8 * 0)) & 0xFF;
00069       offset += sizeof(this->allow_free_yaw_axis);
00070       *(outbuffer + offset + 0) = (this->mouse_interaction_mode >> (8 * 0)) & 0xFF;
00071       offset += sizeof(this->mouse_interaction_mode);
00072       union {
00073         bool real;
00074         uint8_t base;
00075       } u_interaction_disabled;
00076       u_interaction_disabled.real = this->interaction_disabled;
00077       *(outbuffer + offset + 0) = (u_interaction_disabled.base >> (8 * 0)) & 0xFF;
00078       offset += sizeof(this->interaction_disabled);
00079       union {
00080         bool real;
00081         uint8_t base;
00082       } u_render_frame_by_frame;
00083       u_render_frame_by_frame.real = this->render_frame_by_frame;
00084       *(outbuffer + offset + 0) = (u_render_frame_by_frame.base >> (8 * 0)) & 0xFF;
00085       offset += sizeof(this->render_frame_by_frame);
00086       union {
00087         int8_t real;
00088         uint8_t base;
00089       } u_frames_per_second;
00090       u_frames_per_second.real = this->frames_per_second;
00091       *(outbuffer + offset + 0) = (u_frames_per_second.base >> (8 * 0)) & 0xFF;
00092       offset += sizeof(this->frames_per_second);
00093       return offset;
00094     }
00095 
00096     virtual int deserialize(unsigned char *inbuffer)
00097     {
00098       int offset = 0;
00099       uint32_t trajectory_lengthT = ((uint32_t) (*(inbuffer + offset))); 
00100       trajectory_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 
00101       trajectory_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 
00102       trajectory_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 
00103       offset += sizeof(this->trajectory_length);
00104       if(trajectory_lengthT > trajectory_length)
00105         this->trajectory = (view_controller_msgs::CameraMovement*)realloc(this->trajectory, trajectory_lengthT * sizeof(view_controller_msgs::CameraMovement));
00106       trajectory_length = trajectory_lengthT;
00107       for( uint32_t i = 0; i < trajectory_length; i++){
00108       offset += this->st_trajectory.deserialize(inbuffer + offset);
00109         memcpy( &(this->trajectory[i]), &(this->st_trajectory), sizeof(view_controller_msgs::CameraMovement));
00110       }
00111       uint32_t length_target_frame;
00112       arrToVar(length_target_frame, (inbuffer + offset));
00113       offset += 4;
00114       for(unsigned int k= offset; k< offset+length_target_frame; ++k){
00115           inbuffer[k-1]=inbuffer[k];
00116       }
00117       inbuffer[offset+length_target_frame-1]=0;
00118       this->target_frame = (char *)(inbuffer + offset-1);
00119       offset += length_target_frame;
00120       union {
00121         bool real;
00122         uint8_t base;
00123       } u_allow_free_yaw_axis;
00124       u_allow_free_yaw_axis.base = 0;
00125       u_allow_free_yaw_axis.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
00126       this->allow_free_yaw_axis = u_allow_free_yaw_axis.real;
00127       offset += sizeof(this->allow_free_yaw_axis);
00128       this->mouse_interaction_mode =  ((uint8_t) (*(inbuffer + offset)));
00129       offset += sizeof(this->mouse_interaction_mode);
00130       union {
00131         bool real;
00132         uint8_t base;
00133       } u_interaction_disabled;
00134       u_interaction_disabled.base = 0;
00135       u_interaction_disabled.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
00136       this->interaction_disabled = u_interaction_disabled.real;
00137       offset += sizeof(this->interaction_disabled);
00138       union {
00139         bool real;
00140         uint8_t base;
00141       } u_render_frame_by_frame;
00142       u_render_frame_by_frame.base = 0;
00143       u_render_frame_by_frame.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
00144       this->render_frame_by_frame = u_render_frame_by_frame.real;
00145       offset += sizeof(this->render_frame_by_frame);
00146       union {
00147         int8_t real;
00148         uint8_t base;
00149       } u_frames_per_second;
00150       u_frames_per_second.base = 0;
00151       u_frames_per_second.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
00152       this->frames_per_second = u_frames_per_second.real;
00153       offset += sizeof(this->frames_per_second);
00154      return offset;
00155     }
00156 
00157     virtual const char * getType(){ return "view_controller_msgs/CameraTrajectory"; };
00158     virtual const char * getMD5(){ return "c56d6e838f60da69466a74c60cf627d7"; };
00159 
00160   };
00161 
00162 }
00163 #endif