Marker.h

00001 #ifndef _ROS_visualization_msgs_Marker_h
00002 #define _ROS_visualization_msgs_Marker_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/Pose.h"
00010 #include "geometry_msgs/Vector3.h"
00011 #include "std_msgs/ColorRGBA.h"
00012 #include "ros/duration.h"
00013 #include "geometry_msgs/Point.h"
00014 
00015 namespace visualization_msgs
00016 {
00017 
00018   class Marker : public ros::Msg
00019   {
00020     public:
00021       std_msgs::Header header;
00022       const char* ns;
00023       int32_t id;
00024       int32_t type;
00025       int32_t action;
00026       geometry_msgs::Pose pose;
00027       geometry_msgs::Vector3 scale;
00028       std_msgs::ColorRGBA color;
00029       ros::Duration lifetime;
00030       bool frame_locked;
00031       uint8_t points_length;
00032       geometry_msgs::Point st_points;
00033       geometry_msgs::Point * points;
00034       uint8_t colors_length;
00035       std_msgs::ColorRGBA st_colors;
00036       std_msgs::ColorRGBA * colors;
00037       const char* text;
00038       const char* mesh_resource;
00039       bool mesh_use_embedded_materials;
00040       enum { ARROW = 0 };
00041       enum { CUBE = 1 };
00042       enum { SPHERE = 2 };
00043       enum { CYLINDER = 3 };
00044       enum { LINE_STRIP = 4 };
00045       enum { LINE_LIST = 5 };
00046       enum { CUBE_LIST = 6 };
00047       enum { SPHERE_LIST = 7 };
00048       enum { POINTS = 8 };
00049       enum { TEXT_VIEW_FACING = 9 };
00050       enum { MESH_RESOURCE = 10 };
00051       enum { TRIANGLE_LIST = 11 };
00052       enum { ADD = 0 };
00053       enum { MODIFY = 0 };
00054       enum { DELETE = 2 };
00055 
00056     Marker():
00057       header(),
00058       ns(""),
00059       id(0),
00060       type(0),
00061       action(0),
00062       pose(),
00063       scale(),
00064       color(),
00065       lifetime(),
00066       frame_locked(0),
00067       points_length(0), points(NULL),
00068       colors_length(0), colors(NULL),
00069       text(""),
00070       mesh_resource(""),
00071       mesh_use_embedded_materials(0)
00072     {
00073     }
00074 
00075     virtual int serialize(unsigned char *outbuffer) const
00076     {
00077       int offset = 0;
00078       offset += this->header.serialize(outbuffer + offset);
00079       uint32_t length_ns = strlen(this->ns);
00080       memcpy(outbuffer + offset, &length_ns, sizeof(uint32_t));
00081       offset += 4;
00082       memcpy(outbuffer + offset, this->ns, length_ns);
00083       offset += length_ns;
00084       union {
00085         int32_t real;
00086         uint32_t base;
00087       } u_id;
00088       u_id.real = this->id;
00089       *(outbuffer + offset + 0) = (u_id.base >> (8 * 0)) & 0xFF;
00090       *(outbuffer + offset + 1) = (u_id.base >> (8 * 1)) & 0xFF;
00091       *(outbuffer + offset + 2) = (u_id.base >> (8 * 2)) & 0xFF;
00092       *(outbuffer + offset + 3) = (u_id.base >> (8 * 3)) & 0xFF;
00093       offset += sizeof(this->id);
00094       union {
00095         int32_t real;
00096         uint32_t base;
00097       } u_type;
00098       u_type.real = this->type;
00099       *(outbuffer + offset + 0) = (u_type.base >> (8 * 0)) & 0xFF;
00100       *(outbuffer + offset + 1) = (u_type.base >> (8 * 1)) & 0xFF;
00101       *(outbuffer + offset + 2) = (u_type.base >> (8 * 2)) & 0xFF;
00102       *(outbuffer + offset + 3) = (u_type.base >> (8 * 3)) & 0xFF;
00103       offset += sizeof(this->type);
00104       union {
00105         int32_t real;
00106         uint32_t base;
00107       } u_action;
00108       u_action.real = this->action;
00109       *(outbuffer + offset + 0) = (u_action.base >> (8 * 0)) & 0xFF;
00110       *(outbuffer + offset + 1) = (u_action.base >> (8 * 1)) & 0xFF;
00111       *(outbuffer + offset + 2) = (u_action.base >> (8 * 2)) & 0xFF;
00112       *(outbuffer + offset + 3) = (u_action.base >> (8 * 3)) & 0xFF;
00113       offset += sizeof(this->action);
00114       offset += this->pose.serialize(outbuffer + offset);
00115       offset += this->scale.serialize(outbuffer + offset);
00116       offset += this->color.serialize(outbuffer + offset);
00117       *(outbuffer + offset + 0) = (this->lifetime.sec >> (8 * 0)) & 0xFF;
00118       *(outbuffer + offset + 1) = (this->lifetime.sec >> (8 * 1)) & 0xFF;
00119       *(outbuffer + offset + 2) = (this->lifetime.sec >> (8 * 2)) & 0xFF;
00120       *(outbuffer + offset + 3) = (this->lifetime.sec >> (8 * 3)) & 0xFF;
00121       offset += sizeof(this->lifetime.sec);
00122       *(outbuffer + offset + 0) = (this->lifetime.nsec >> (8 * 0)) & 0xFF;
00123       *(outbuffer + offset + 1) = (this->lifetime.nsec >> (8 * 1)) & 0xFF;
00124       *(outbuffer + offset + 2) = (this->lifetime.nsec >> (8 * 2)) & 0xFF;
00125       *(outbuffer + offset + 3) = (this->lifetime.nsec >> (8 * 3)) & 0xFF;
00126       offset += sizeof(this->lifetime.nsec);
00127       union {
00128         bool real;
00129         uint8_t base;
00130       } u_frame_locked;
00131       u_frame_locked.real = this->frame_locked;
00132       *(outbuffer + offset + 0) = (u_frame_locked.base >> (8 * 0)) & 0xFF;
00133       offset += sizeof(this->frame_locked);
00134       *(outbuffer + offset++) = points_length;
00135       *(outbuffer + offset++) = 0;
00136       *(outbuffer + offset++) = 0;
00137       *(outbuffer + offset++) = 0;
00138       for( uint8_t i = 0; i < points_length; i++){
00139       offset += this->points[i].serialize(outbuffer + offset);
00140       }
00141       *(outbuffer + offset++) = colors_length;
00142       *(outbuffer + offset++) = 0;
00143       *(outbuffer + offset++) = 0;
00144       *(outbuffer + offset++) = 0;
00145       for( uint8_t i = 0; i < colors_length; i++){
00146       offset += this->colors[i].serialize(outbuffer + offset);
00147       }
00148       uint32_t length_text = strlen(this->text);
00149       memcpy(outbuffer + offset, &length_text, sizeof(uint32_t));
00150       offset += 4;
00151       memcpy(outbuffer + offset, this->text, length_text);
00152       offset += length_text;
00153       uint32_t length_mesh_resource = strlen(this->mesh_resource);
00154       memcpy(outbuffer + offset, &length_mesh_resource, sizeof(uint32_t));
00155       offset += 4;
00156       memcpy(outbuffer + offset, this->mesh_resource, length_mesh_resource);
00157       offset += length_mesh_resource;
00158       union {
00159         bool real;
00160         uint8_t base;
00161       } u_mesh_use_embedded_materials;
00162       u_mesh_use_embedded_materials.real = this->mesh_use_embedded_materials;
00163       *(outbuffer + offset + 0) = (u_mesh_use_embedded_materials.base >> (8 * 0)) & 0xFF;
00164       offset += sizeof(this->mesh_use_embedded_materials);
00165       return offset;
00166     }
00167 
00168     virtual int deserialize(unsigned char *inbuffer)
00169     {
00170       int offset = 0;
00171       offset += this->header.deserialize(inbuffer + offset);
00172       uint32_t length_ns;
00173       memcpy(&length_ns, (inbuffer + offset), sizeof(uint32_t));
00174       offset += 4;
00175       for(unsigned int k= offset; k< offset+length_ns; ++k){
00176           inbuffer[k-1]=inbuffer[k];
00177       }
00178       inbuffer[offset+length_ns-1]=0;
00179       this->ns = (char *)(inbuffer + offset-1);
00180       offset += length_ns;
00181       union {
00182         int32_t real;
00183         uint32_t base;
00184       } u_id;
00185       u_id.base = 0;
00186       u_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
00187       u_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00188       u_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00189       u_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00190       this->id = u_id.real;
00191       offset += sizeof(this->id);
00192       union {
00193         int32_t real;
00194         uint32_t base;
00195       } u_type;
00196       u_type.base = 0;
00197       u_type.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
00198       u_type.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00199       u_type.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00200       u_type.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00201       this->type = u_type.real;
00202       offset += sizeof(this->type);
00203       union {
00204         int32_t real;
00205         uint32_t base;
00206       } u_action;
00207       u_action.base = 0;
00208       u_action.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
00209       u_action.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00210       u_action.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00211       u_action.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00212       this->action = u_action.real;
00213       offset += sizeof(this->action);
00214       offset += this->pose.deserialize(inbuffer + offset);
00215       offset += this->scale.deserialize(inbuffer + offset);
00216       offset += this->color.deserialize(inbuffer + offset);
00217       this->lifetime.sec =  ((uint32_t) (*(inbuffer + offset)));
00218       this->lifetime.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00219       this->lifetime.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00220       this->lifetime.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00221       offset += sizeof(this->lifetime.sec);
00222       this->lifetime.nsec =  ((uint32_t) (*(inbuffer + offset)));
00223       this->lifetime.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00224       this->lifetime.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00225       this->lifetime.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00226       offset += sizeof(this->lifetime.nsec);
00227       union {
00228         bool real;
00229         uint8_t base;
00230       } u_frame_locked;
00231       u_frame_locked.base = 0;
00232       u_frame_locked.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
00233       this->frame_locked = u_frame_locked.real;
00234       offset += sizeof(this->frame_locked);
00235       uint8_t points_lengthT = *(inbuffer + offset++);
00236       if(points_lengthT > points_length)
00237         this->points = (geometry_msgs::Point*)realloc(this->points, points_lengthT * sizeof(geometry_msgs::Point));
00238       offset += 3;
00239       points_length = points_lengthT;
00240       for( uint8_t i = 0; i < points_length; i++){
00241       offset += this->st_points.deserialize(inbuffer + offset);
00242         memcpy( &(this->points[i]), &(this->st_points), sizeof(geometry_msgs::Point));
00243       }
00244       uint8_t colors_lengthT = *(inbuffer + offset++);
00245       if(colors_lengthT > colors_length)
00246         this->colors = (std_msgs::ColorRGBA*)realloc(this->colors, colors_lengthT * sizeof(std_msgs::ColorRGBA));
00247       offset += 3;
00248       colors_length = colors_lengthT;
00249       for( uint8_t i = 0; i < colors_length; i++){
00250       offset += this->st_colors.deserialize(inbuffer + offset);
00251         memcpy( &(this->colors[i]), &(this->st_colors), sizeof(std_msgs::ColorRGBA));
00252       }
00253       uint32_t length_text;
00254       memcpy(&length_text, (inbuffer + offset), sizeof(uint32_t));
00255       offset += 4;
00256       for(unsigned int k= offset; k< offset+length_text; ++k){
00257           inbuffer[k-1]=inbuffer[k];
00258       }
00259       inbuffer[offset+length_text-1]=0;
00260       this->text = (char *)(inbuffer + offset-1);
00261       offset += length_text;
00262       uint32_t length_mesh_resource;
00263       memcpy(&length_mesh_resource, (inbuffer + offset), sizeof(uint32_t));
00264       offset += 4;
00265       for(unsigned int k= offset; k< offset+length_mesh_resource; ++k){
00266           inbuffer[k-1]=inbuffer[k];
00267       }
00268       inbuffer[offset+length_mesh_resource-1]=0;
00269       this->mesh_resource = (char *)(inbuffer + offset-1);
00270       offset += length_mesh_resource;
00271       union {
00272         bool real;
00273         uint8_t base;
00274       } u_mesh_use_embedded_materials;
00275       u_mesh_use_embedded_materials.base = 0;
00276       u_mesh_use_embedded_materials.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
00277       this->mesh_use_embedded_materials = u_mesh_use_embedded_materials.real;
00278       offset += sizeof(this->mesh_use_embedded_materials);
00279      return offset;
00280     }
00281 
00282     const char * getType(){ return "visualization_msgs/Marker"; };
00283     const char * getMD5(){ return "18326976df9d29249efc939e00342cde"; };
00284 
00285   };
00286 
00287 }
00288 #endif