catchrobo2022
/
catchrobo2022_mbed
Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Dependencies: mbed
Embed:
(wiki syntax)
Show/hide line numbers
ClassificationResult.h
00001 #ifndef _ROS_jsk_recognition_msgs_ClassificationResult_h 00002 #define _ROS_jsk_recognition_msgs_ClassificationResult_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 00010 namespace jsk_recognition_msgs 00011 { 00012 00013 class ClassificationResult : public ros::Msg 00014 { 00015 public: 00016 typedef std_msgs::Header _header_type; 00017 _header_type header; 00018 uint32_t labels_length; 00019 typedef uint32_t _labels_type; 00020 _labels_type st_labels; 00021 _labels_type * labels; 00022 uint32_t label_names_length; 00023 typedef char* _label_names_type; 00024 _label_names_type st_label_names; 00025 _label_names_type * label_names; 00026 uint32_t label_proba_length; 00027 typedef double _label_proba_type; 00028 _label_proba_type st_label_proba; 00029 _label_proba_type * label_proba; 00030 uint32_t probabilities_length; 00031 typedef double _probabilities_type; 00032 _probabilities_type st_probabilities; 00033 _probabilities_type * probabilities; 00034 typedef const char* _classifier_type; 00035 _classifier_type classifier; 00036 uint32_t target_names_length; 00037 typedef char* _target_names_type; 00038 _target_names_type st_target_names; 00039 _target_names_type * target_names; 00040 00041 ClassificationResult(): 00042 header(), 00043 labels_length(0), labels(NULL), 00044 label_names_length(0), label_names(NULL), 00045 label_proba_length(0), label_proba(NULL), 00046 probabilities_length(0), probabilities(NULL), 00047 classifier(""), 00048 target_names_length(0), target_names(NULL) 00049 { 00050 } 00051 00052 virtual int serialize(unsigned char *outbuffer) const 00053 { 00054 int offset = 0; 00055 offset += this->header.serialize(outbuffer + offset); 00056 *(outbuffer + offset + 0) = (this->labels_length >> (8 * 0)) & 0xFF; 00057 *(outbuffer + offset + 1) = (this->labels_length >> (8 * 1)) & 0xFF; 00058 *(outbuffer + offset + 2) = (this->labels_length >> (8 * 2)) & 0xFF; 00059 *(outbuffer + offset + 3) = (this->labels_length >> (8 * 3)) & 0xFF; 00060 offset += sizeof(this->labels_length); 00061 for( uint32_t i = 0; i < labels_length; i++){ 00062 *(outbuffer + offset + 0) = (this->labels[i] >> (8 * 0)) & 0xFF; 00063 *(outbuffer + offset + 1) = (this->labels[i] >> (8 * 1)) & 0xFF; 00064 *(outbuffer + offset + 2) = (this->labels[i] >> (8 * 2)) & 0xFF; 00065 *(outbuffer + offset + 3) = (this->labels[i] >> (8 * 3)) & 0xFF; 00066 offset += sizeof(this->labels[i]); 00067 } 00068 *(outbuffer + offset + 0) = (this->label_names_length >> (8 * 0)) & 0xFF; 00069 *(outbuffer + offset + 1) = (this->label_names_length >> (8 * 1)) & 0xFF; 00070 *(outbuffer + offset + 2) = (this->label_names_length >> (8 * 2)) & 0xFF; 00071 *(outbuffer + offset + 3) = (this->label_names_length >> (8 * 3)) & 0xFF; 00072 offset += sizeof(this->label_names_length); 00073 for( uint32_t i = 0; i < label_names_length; i++){ 00074 uint32_t length_label_namesi = strlen(this->label_names[i]); 00075 varToArr(outbuffer + offset, length_label_namesi); 00076 offset += 4; 00077 memcpy(outbuffer + offset, this->label_names[i], length_label_namesi); 00078 offset += length_label_namesi; 00079 } 00080 *(outbuffer + offset + 0) = (this->label_proba_length >> (8 * 0)) & 0xFF; 00081 *(outbuffer + offset + 1) = (this->label_proba_length >> (8 * 1)) & 0xFF; 00082 *(outbuffer + offset + 2) = (this->label_proba_length >> (8 * 2)) & 0xFF; 00083 *(outbuffer + offset + 3) = (this->label_proba_length >> (8 * 3)) & 0xFF; 00084 offset += sizeof(this->label_proba_length); 00085 for( uint32_t i = 0; i < label_proba_length; i++){ 00086 union { 00087 double real; 00088 uint64_t base; 00089 } u_label_probai; 00090 u_label_probai.real = this->label_proba[i]; 00091 *(outbuffer + offset + 0) = (u_label_probai.base >> (8 * 0)) & 0xFF; 00092 *(outbuffer + offset + 1) = (u_label_probai.base >> (8 * 1)) & 0xFF; 00093 *(outbuffer + offset + 2) = (u_label_probai.base >> (8 * 2)) & 0xFF; 00094 *(outbuffer + offset + 3) = (u_label_probai.base >> (8 * 3)) & 0xFF; 00095 *(outbuffer + offset + 4) = (u_label_probai.base >> (8 * 4)) & 0xFF; 00096 *(outbuffer + offset + 5) = (u_label_probai.base >> (8 * 5)) & 0xFF; 00097 *(outbuffer + offset + 6) = (u_label_probai.base >> (8 * 6)) & 0xFF; 00098 *(outbuffer + offset + 7) = (u_label_probai.base >> (8 * 7)) & 0xFF; 00099 offset += sizeof(this->label_proba[i]); 00100 } 00101 *(outbuffer + offset + 0) = (this->probabilities_length >> (8 * 0)) & 0xFF; 00102 *(outbuffer + offset + 1) = (this->probabilities_length >> (8 * 1)) & 0xFF; 00103 *(outbuffer + offset + 2) = (this->probabilities_length >> (8 * 2)) & 0xFF; 00104 *(outbuffer + offset + 3) = (this->probabilities_length >> (8 * 3)) & 0xFF; 00105 offset += sizeof(this->probabilities_length); 00106 for( uint32_t i = 0; i < probabilities_length; i++){ 00107 union { 00108 double real; 00109 uint64_t base; 00110 } u_probabilitiesi; 00111 u_probabilitiesi.real = this->probabilities[i]; 00112 *(outbuffer + offset + 0) = (u_probabilitiesi.base >> (8 * 0)) & 0xFF; 00113 *(outbuffer + offset + 1) = (u_probabilitiesi.base >> (8 * 1)) & 0xFF; 00114 *(outbuffer + offset + 2) = (u_probabilitiesi.base >> (8 * 2)) & 0xFF; 00115 *(outbuffer + offset + 3) = (u_probabilitiesi.base >> (8 * 3)) & 0xFF; 00116 *(outbuffer + offset + 4) = (u_probabilitiesi.base >> (8 * 4)) & 0xFF; 00117 *(outbuffer + offset + 5) = (u_probabilitiesi.base >> (8 * 5)) & 0xFF; 00118 *(outbuffer + offset + 6) = (u_probabilitiesi.base >> (8 * 6)) & 0xFF; 00119 *(outbuffer + offset + 7) = (u_probabilitiesi.base >> (8 * 7)) & 0xFF; 00120 offset += sizeof(this->probabilities[i]); 00121 } 00122 uint32_t length_classifier = strlen(this->classifier); 00123 varToArr(outbuffer + offset, length_classifier); 00124 offset += 4; 00125 memcpy(outbuffer + offset, this->classifier, length_classifier); 00126 offset += length_classifier; 00127 *(outbuffer + offset + 0) = (this->target_names_length >> (8 * 0)) & 0xFF; 00128 *(outbuffer + offset + 1) = (this->target_names_length >> (8 * 1)) & 0xFF; 00129 *(outbuffer + offset + 2) = (this->target_names_length >> (8 * 2)) & 0xFF; 00130 *(outbuffer + offset + 3) = (this->target_names_length >> (8 * 3)) & 0xFF; 00131 offset += sizeof(this->target_names_length); 00132 for( uint32_t i = 0; i < target_names_length; i++){ 00133 uint32_t length_target_namesi = strlen(this->target_names[i]); 00134 varToArr(outbuffer + offset, length_target_namesi); 00135 offset += 4; 00136 memcpy(outbuffer + offset, this->target_names[i], length_target_namesi); 00137 offset += length_target_namesi; 00138 } 00139 return offset; 00140 } 00141 00142 virtual int deserialize(unsigned char *inbuffer) 00143 { 00144 int offset = 0; 00145 offset += this->header.deserialize(inbuffer + offset); 00146 uint32_t labels_lengthT = ((uint32_t) (*(inbuffer + offset))); 00147 labels_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00148 labels_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00149 labels_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00150 offset += sizeof(this->labels_length); 00151 if(labels_lengthT > labels_length) 00152 this->labels = (uint32_t*)realloc(this->labels, labels_lengthT * sizeof(uint32_t)); 00153 labels_length = labels_lengthT; 00154 for( uint32_t i = 0; i < labels_length; i++){ 00155 this->st_labels = ((uint32_t) (*(inbuffer + offset))); 00156 this->st_labels |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00157 this->st_labels |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00158 this->st_labels |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00159 offset += sizeof(this->st_labels); 00160 memcpy( &(this->labels[i]), &(this->st_labels), sizeof(uint32_t)); 00161 } 00162 uint32_t label_names_lengthT = ((uint32_t) (*(inbuffer + offset))); 00163 label_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00164 label_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00165 label_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00166 offset += sizeof(this->label_names_length); 00167 if(label_names_lengthT > label_names_length) 00168 this->label_names = (char**)realloc(this->label_names, label_names_lengthT * sizeof(char*)); 00169 label_names_length = label_names_lengthT; 00170 for( uint32_t i = 0; i < label_names_length; i++){ 00171 uint32_t length_st_label_names; 00172 arrToVar(length_st_label_names, (inbuffer + offset)); 00173 offset += 4; 00174 for(unsigned int k= offset; k< offset+length_st_label_names; ++k){ 00175 inbuffer[k-1]=inbuffer[k]; 00176 } 00177 inbuffer[offset+length_st_label_names-1]=0; 00178 this->st_label_names = (char *)(inbuffer + offset-1); 00179 offset += length_st_label_names; 00180 memcpy( &(this->label_names[i]), &(this->st_label_names), sizeof(char*)); 00181 } 00182 uint32_t label_proba_lengthT = ((uint32_t) (*(inbuffer + offset))); 00183 label_proba_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00184 label_proba_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00185 label_proba_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00186 offset += sizeof(this->label_proba_length); 00187 if(label_proba_lengthT > label_proba_length) 00188 this->label_proba = (double*)realloc(this->label_proba, label_proba_lengthT * sizeof(double)); 00189 label_proba_length = label_proba_lengthT; 00190 for( uint32_t i = 0; i < label_proba_length; i++){ 00191 union { 00192 double real; 00193 uint64_t base; 00194 } u_st_label_proba; 00195 u_st_label_proba.base = 0; 00196 u_st_label_proba.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); 00197 u_st_label_proba.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); 00198 u_st_label_proba.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); 00199 u_st_label_proba.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); 00200 u_st_label_proba.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); 00201 u_st_label_proba.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); 00202 u_st_label_proba.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); 00203 u_st_label_proba.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); 00204 this->st_label_proba = u_st_label_proba.real; 00205 offset += sizeof(this->st_label_proba); 00206 memcpy( &(this->label_proba[i]), &(this->st_label_proba), sizeof(double)); 00207 } 00208 uint32_t probabilities_lengthT = ((uint32_t) (*(inbuffer + offset))); 00209 probabilities_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00210 probabilities_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00211 probabilities_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00212 offset += sizeof(this->probabilities_length); 00213 if(probabilities_lengthT > probabilities_length) 00214 this->probabilities = (double*)realloc(this->probabilities, probabilities_lengthT * sizeof(double)); 00215 probabilities_length = probabilities_lengthT; 00216 for( uint32_t i = 0; i < probabilities_length; i++){ 00217 union { 00218 double real; 00219 uint64_t base; 00220 } u_st_probabilities; 00221 u_st_probabilities.base = 0; 00222 u_st_probabilities.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); 00223 u_st_probabilities.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); 00224 u_st_probabilities.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); 00225 u_st_probabilities.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); 00226 u_st_probabilities.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); 00227 u_st_probabilities.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); 00228 u_st_probabilities.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); 00229 u_st_probabilities.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); 00230 this->st_probabilities = u_st_probabilities.real; 00231 offset += sizeof(this->st_probabilities); 00232 memcpy( &(this->probabilities[i]), &(this->st_probabilities), sizeof(double)); 00233 } 00234 uint32_t length_classifier; 00235 arrToVar(length_classifier, (inbuffer + offset)); 00236 offset += 4; 00237 for(unsigned int k= offset; k< offset+length_classifier; ++k){ 00238 inbuffer[k-1]=inbuffer[k]; 00239 } 00240 inbuffer[offset+length_classifier-1]=0; 00241 this->classifier = (char *)(inbuffer + offset-1); 00242 offset += length_classifier; 00243 uint32_t target_names_lengthT = ((uint32_t) (*(inbuffer + offset))); 00244 target_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00245 target_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00246 target_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00247 offset += sizeof(this->target_names_length); 00248 if(target_names_lengthT > target_names_length) 00249 this->target_names = (char**)realloc(this->target_names, target_names_lengthT * sizeof(char*)); 00250 target_names_length = target_names_lengthT; 00251 for( uint32_t i = 0; i < target_names_length; i++){ 00252 uint32_t length_st_target_names; 00253 arrToVar(length_st_target_names, (inbuffer + offset)); 00254 offset += 4; 00255 for(unsigned int k= offset; k< offset+length_st_target_names; ++k){ 00256 inbuffer[k-1]=inbuffer[k]; 00257 } 00258 inbuffer[offset+length_st_target_names-1]=0; 00259 this->st_target_names = (char *)(inbuffer + offset-1); 00260 offset += length_st_target_names; 00261 memcpy( &(this->target_names[i]), &(this->st_target_names), sizeof(char*)); 00262 } 00263 return offset; 00264 } 00265 00266 virtual const char * getType(){ return "jsk_recognition_msgs/ClassificationResult"; }; 00267 virtual const char * getMD5(){ return "cce1f8edabff85a20e9cc013e319497c"; }; 00268 00269 }; 00270 00271 } 00272 #endif
Generated on Mon Sep 26 2022 13:47:00 by
1.7.2