ObjectRecognitionGoal.h

00001 #ifndef _ROS_object_recognition_msgs_ObjectRecognitionGoal_h
00002 #define _ROS_object_recognition_msgs_ObjectRecognitionGoal_h
00003 
00004 #include <stdint.h>
00005 #include <string.h>
00006 #include <stdlib.h>
00007 #include "ros/msg.h"
00008 
00009 namespace object_recognition_msgs
00010 {
00011 
00012   class ObjectRecognitionGoal : public ros::Msg
00013   {
00014     public:
00015       typedef bool _use_roi_type;
00016       _use_roi_type use_roi;
00017       uint32_t filter_limits_length;
00018       typedef float _filter_limits_type;
00019       _filter_limits_type st_filter_limits;
00020       _filter_limits_type * filter_limits;
00021 
00022     ObjectRecognitionGoal():
00023       use_roi(0),
00024       filter_limits_length(0), filter_limits(NULL)
00025     {
00026     }
00027 
00028     virtual int serialize(unsigned char *outbuffer) const
00029     {
00030       int offset = 0;
00031       union {
00032         bool real;
00033         uint8_t base;
00034       } u_use_roi;
00035       u_use_roi.real = this->use_roi;
00036       *(outbuffer + offset + 0) = (u_use_roi.base >> (8 * 0)) & 0xFF;
00037       offset += sizeof(this->use_roi);
00038       *(outbuffer + offset + 0) = (this->filter_limits_length >> (8 * 0)) & 0xFF;
00039       *(outbuffer + offset + 1) = (this->filter_limits_length >> (8 * 1)) & 0xFF;
00040       *(outbuffer + offset + 2) = (this->filter_limits_length >> (8 * 2)) & 0xFF;
00041       *(outbuffer + offset + 3) = (this->filter_limits_length >> (8 * 3)) & 0xFF;
00042       offset += sizeof(this->filter_limits_length);
00043       for( uint32_t i = 0; i < filter_limits_length; i++){
00044       union {
00045         float real;
00046         uint32_t base;
00047       } u_filter_limitsi;
00048       u_filter_limitsi.real = this->filter_limits[i];
00049       *(outbuffer + offset + 0) = (u_filter_limitsi.base >> (8 * 0)) & 0xFF;
00050       *(outbuffer + offset + 1) = (u_filter_limitsi.base >> (8 * 1)) & 0xFF;
00051       *(outbuffer + offset + 2) = (u_filter_limitsi.base >> (8 * 2)) & 0xFF;
00052       *(outbuffer + offset + 3) = (u_filter_limitsi.base >> (8 * 3)) & 0xFF;
00053       offset += sizeof(this->filter_limits[i]);
00054       }
00055       return offset;
00056     }
00057 
00058     virtual int deserialize(unsigned char *inbuffer)
00059     {
00060       int offset = 0;
00061       union {
00062         bool real;
00063         uint8_t base;
00064       } u_use_roi;
00065       u_use_roi.base = 0;
00066       u_use_roi.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
00067       this->use_roi = u_use_roi.real;
00068       offset += sizeof(this->use_roi);
00069       uint32_t filter_limits_lengthT = ((uint32_t) (*(inbuffer + offset))); 
00070       filter_limits_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 
00071       filter_limits_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 
00072       filter_limits_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 
00073       offset += sizeof(this->filter_limits_length);
00074       if(filter_limits_lengthT > filter_limits_length)
00075         this->filter_limits = (float*)realloc(this->filter_limits, filter_limits_lengthT * sizeof(float));
00076       filter_limits_length = filter_limits_lengthT;
00077       for( uint32_t i = 0; i < filter_limits_length; i++){
00078       union {
00079         float real;
00080         uint32_t base;
00081       } u_st_filter_limits;
00082       u_st_filter_limits.base = 0;
00083       u_st_filter_limits.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
00084       u_st_filter_limits.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00085       u_st_filter_limits.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00086       u_st_filter_limits.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00087       this->st_filter_limits = u_st_filter_limits.real;
00088       offset += sizeof(this->st_filter_limits);
00089         memcpy( &(this->filter_limits[i]), &(this->st_filter_limits), sizeof(float));
00090       }
00091      return offset;
00092     }
00093 
00094     virtual const char * getType(){ return "object_recognition_msgs/ObjectRecognitionGoal"; };
00095     virtual const char * getMD5(){ return "49bea2f03a1bba0ad05926e01e3525fa"; };
00096 
00097   };
00098 
00099 }
00100 #endif