PolygonArray.h

00001 #ifndef _ROS_jsk_recognition_msgs_PolygonArray_h
00002 #define _ROS_jsk_recognition_msgs_PolygonArray_h
00003 
00004 #include <stdint.h>
00005 #include <string.h>
00006 #include <stdlib.h>
00007 #include "ros/msg.h"
00008 #include "std_msgs/Header.h"
00009 #include "geometry_msgs/PolygonStamped.h"
00010 
00011 namespace jsk_recognition_msgs
00012 {
00013 
00014   class PolygonArray : public ros::Msg
00015   {
00016     public:
00017       typedef std_msgs::Header _header_type;
00018       _header_type header;
00019       uint32_t polygons_length;
00020       typedef geometry_msgs::PolygonStamped _polygons_type;
00021       _polygons_type st_polygons;
00022       _polygons_type * polygons;
00023       uint32_t labels_length;
00024       typedef uint32_t _labels_type;
00025       _labels_type st_labels;
00026       _labels_type * labels;
00027       uint32_t likelihood_length;
00028       typedef float _likelihood_type;
00029       _likelihood_type st_likelihood;
00030       _likelihood_type * likelihood;
00031 
00032     PolygonArray():
00033       header(),
00034       polygons_length(0), polygons(NULL),
00035       labels_length(0), labels(NULL),
00036       likelihood_length(0), likelihood(NULL)
00037     {
00038     }
00039 
00040     virtual int serialize(unsigned char *outbuffer) const
00041     {
00042       int offset = 0;
00043       offset += this->header.serialize(outbuffer + offset);
00044       *(outbuffer + offset + 0) = (this->polygons_length >> (8 * 0)) & 0xFF;
00045       *(outbuffer + offset + 1) = (this->polygons_length >> (8 * 1)) & 0xFF;
00046       *(outbuffer + offset + 2) = (this->polygons_length >> (8 * 2)) & 0xFF;
00047       *(outbuffer + offset + 3) = (this->polygons_length >> (8 * 3)) & 0xFF;
00048       offset += sizeof(this->polygons_length);
00049       for( uint32_t i = 0; i < polygons_length; i++){
00050       offset += this->polygons[i].serialize(outbuffer + offset);
00051       }
00052       *(outbuffer + offset + 0) = (this->labels_length >> (8 * 0)) & 0xFF;
00053       *(outbuffer + offset + 1) = (this->labels_length >> (8 * 1)) & 0xFF;
00054       *(outbuffer + offset + 2) = (this->labels_length >> (8 * 2)) & 0xFF;
00055       *(outbuffer + offset + 3) = (this->labels_length >> (8 * 3)) & 0xFF;
00056       offset += sizeof(this->labels_length);
00057       for( uint32_t i = 0; i < labels_length; i++){
00058       *(outbuffer + offset + 0) = (this->labels[i] >> (8 * 0)) & 0xFF;
00059       *(outbuffer + offset + 1) = (this->labels[i] >> (8 * 1)) & 0xFF;
00060       *(outbuffer + offset + 2) = (this->labels[i] >> (8 * 2)) & 0xFF;
00061       *(outbuffer + offset + 3) = (this->labels[i] >> (8 * 3)) & 0xFF;
00062       offset += sizeof(this->labels[i]);
00063       }
00064       *(outbuffer + offset + 0) = (this->likelihood_length >> (8 * 0)) & 0xFF;
00065       *(outbuffer + offset + 1) = (this->likelihood_length >> (8 * 1)) & 0xFF;
00066       *(outbuffer + offset + 2) = (this->likelihood_length >> (8 * 2)) & 0xFF;
00067       *(outbuffer + offset + 3) = (this->likelihood_length >> (8 * 3)) & 0xFF;
00068       offset += sizeof(this->likelihood_length);
00069       for( uint32_t i = 0; i < likelihood_length; i++){
00070       union {
00071         float real;
00072         uint32_t base;
00073       } u_likelihoodi;
00074       u_likelihoodi.real = this->likelihood[i];
00075       *(outbuffer + offset + 0) = (u_likelihoodi.base >> (8 * 0)) & 0xFF;
00076       *(outbuffer + offset + 1) = (u_likelihoodi.base >> (8 * 1)) & 0xFF;
00077       *(outbuffer + offset + 2) = (u_likelihoodi.base >> (8 * 2)) & 0xFF;
00078       *(outbuffer + offset + 3) = (u_likelihoodi.base >> (8 * 3)) & 0xFF;
00079       offset += sizeof(this->likelihood[i]);
00080       }
00081       return offset;
00082     }
00083 
00084     virtual int deserialize(unsigned char *inbuffer)
00085     {
00086       int offset = 0;
00087       offset += this->header.deserialize(inbuffer + offset);
00088       uint32_t polygons_lengthT = ((uint32_t) (*(inbuffer + offset))); 
00089       polygons_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 
00090       polygons_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 
00091       polygons_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 
00092       offset += sizeof(this->polygons_length);
00093       if(polygons_lengthT > polygons_length)
00094         this->polygons = (geometry_msgs::PolygonStamped*)realloc(this->polygons, polygons_lengthT * sizeof(geometry_msgs::PolygonStamped));
00095       polygons_length = polygons_lengthT;
00096       for( uint32_t i = 0; i < polygons_length; i++){
00097       offset += this->st_polygons.deserialize(inbuffer + offset);
00098         memcpy( &(this->polygons[i]), &(this->st_polygons), sizeof(geometry_msgs::PolygonStamped));
00099       }
00100       uint32_t labels_lengthT = ((uint32_t) (*(inbuffer + offset))); 
00101       labels_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 
00102       labels_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 
00103       labels_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 
00104       offset += sizeof(this->labels_length);
00105       if(labels_lengthT > labels_length)
00106         this->labels = (uint32_t*)realloc(this->labels, labels_lengthT * sizeof(uint32_t));
00107       labels_length = labels_lengthT;
00108       for( uint32_t i = 0; i < labels_length; i++){
00109       this->st_labels =  ((uint32_t) (*(inbuffer + offset)));
00110       this->st_labels |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00111       this->st_labels |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00112       this->st_labels |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00113       offset += sizeof(this->st_labels);
00114         memcpy( &(this->labels[i]), &(this->st_labels), sizeof(uint32_t));
00115       }
00116       uint32_t likelihood_lengthT = ((uint32_t) (*(inbuffer + offset))); 
00117       likelihood_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 
00118       likelihood_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 
00119       likelihood_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 
00120       offset += sizeof(this->likelihood_length);
00121       if(likelihood_lengthT > likelihood_length)
00122         this->likelihood = (float*)realloc(this->likelihood, likelihood_lengthT * sizeof(float));
00123       likelihood_length = likelihood_lengthT;
00124       for( uint32_t i = 0; i < likelihood_length; i++){
00125       union {
00126         float real;
00127         uint32_t base;
00128       } u_st_likelihood;
00129       u_st_likelihood.base = 0;
00130       u_st_likelihood.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
00131       u_st_likelihood.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00132       u_st_likelihood.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00133       u_st_likelihood.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00134       this->st_likelihood = u_st_likelihood.real;
00135       offset += sizeof(this->st_likelihood);
00136         memcpy( &(this->likelihood[i]), &(this->st_likelihood), sizeof(float));
00137       }
00138      return offset;
00139     }
00140 
00141     virtual const char * getType(){ return "jsk_recognition_msgs/PolygonArray"; };
00142     virtual const char * getMD5(){ return "709b37d39871cfdbbfbd5c41cf9bc2be"; };
00143 
00144   };
00145 
00146 }
00147 #endif