Go to the documentation of this file.00001
00002 #ifndef CAMERA_SELF_FILTER_SERVICE_MASK_H
00003 #define CAMERA_SELF_FILTER_SERVICE_MASK_H
00004 #include <string>
00005 #include <vector>
00006 #include <map>
00007 #include <ostream>
00008 #include "ros/serialization.h"
00009 #include "ros/builtin_message_traits.h"
00010 #include "ros/message_operations.h"
00011 #include "ros/time.h"
00012
00013 #include "ros/macros.h"
00014
00015 #include "ros/assert.h"
00016
00017 #include "ros/service_traits.h"
00018
00019 #include "std_msgs/Header.h"
00020
00021
00022 #include "sensor_msgs/Image.h"
00023
00024 namespace camera_self_filter
00025 {
00026 template <class ContainerAllocator>
00027 struct maskRequest_ {
00028 typedef maskRequest_<ContainerAllocator> Type;
00029
00030 maskRequest_()
00031 : header()
00032 {
00033 }
00034
00035 maskRequest_(const ContainerAllocator& _alloc)
00036 : header(_alloc)
00037 {
00038 }
00039
00040 typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
00041 ::std_msgs::Header_<ContainerAllocator> header;
00042
00043
00044 typedef boost::shared_ptr< ::camera_self_filter::maskRequest_<ContainerAllocator> > Ptr;
00045 typedef boost::shared_ptr< ::camera_self_filter::maskRequest_<ContainerAllocator> const> ConstPtr;
00046 boost::shared_ptr<std::map<std::string, std::string> > __connection_header;
00047 };
00048 typedef ::camera_self_filter::maskRequest_<std::allocator<void> > maskRequest;
00049
00050 typedef boost::shared_ptr< ::camera_self_filter::maskRequest> maskRequestPtr;
00051 typedef boost::shared_ptr< ::camera_self_filter::maskRequest const> maskRequestConstPtr;
00052
00053
00054 template <class ContainerAllocator>
00055 struct maskResponse_ {
00056 typedef maskResponse_<ContainerAllocator> Type;
00057
00058 maskResponse_()
00059 : mask_image()
00060 {
00061 }
00062
00063 maskResponse_(const ContainerAllocator& _alloc)
00064 : mask_image(_alloc)
00065 {
00066 }
00067
00068 typedef ::sensor_msgs::Image_<ContainerAllocator> _mask_image_type;
00069 ::sensor_msgs::Image_<ContainerAllocator> mask_image;
00070
00071
00072 typedef boost::shared_ptr< ::camera_self_filter::maskResponse_<ContainerAllocator> > Ptr;
00073 typedef boost::shared_ptr< ::camera_self_filter::maskResponse_<ContainerAllocator> const> ConstPtr;
00074 boost::shared_ptr<std::map<std::string, std::string> > __connection_header;
00075 };
00076 typedef ::camera_self_filter::maskResponse_<std::allocator<void> > maskResponse;
00077
00078 typedef boost::shared_ptr< ::camera_self_filter::maskResponse> maskResponsePtr;
00079 typedef boost::shared_ptr< ::camera_self_filter::maskResponse const> maskResponseConstPtr;
00080
00081 struct mask
00082 {
00083
00084 typedef maskRequest Request;
00085 typedef maskResponse Response;
00086 Request request;
00087 Response response;
00088
00089 typedef Request RequestType;
00090 typedef Response ResponseType;
00091 };
00092 }
00093
00094 namespace ros
00095 {
00096 namespace message_traits
00097 {
00098 template<class ContainerAllocator> struct IsMessage< ::camera_self_filter::maskRequest_<ContainerAllocator> > : public TrueType {};
00099 template<class ContainerAllocator> struct IsMessage< ::camera_self_filter::maskRequest_<ContainerAllocator> const> : public TrueType {};
00100 template<class ContainerAllocator>
00101 struct MD5Sum< ::camera_self_filter::maskRequest_<ContainerAllocator> > {
00102 static const char* value()
00103 {
00104 return "d7be0bb39af8fb9129d5a76e6b63a290";
00105 }
00106
00107 static const char* value(const ::camera_self_filter::maskRequest_<ContainerAllocator> &) { return value(); }
00108 static const uint64_t static_value1 = 0xd7be0bb39af8fb91ULL;
00109 static const uint64_t static_value2 = 0x29d5a76e6b63a290ULL;
00110 };
00111
00112 template<class ContainerAllocator>
00113 struct DataType< ::camera_self_filter::maskRequest_<ContainerAllocator> > {
00114 static const char* value()
00115 {
00116 return "camera_self_filter/maskRequest";
00117 }
00118
00119 static const char* value(const ::camera_self_filter::maskRequest_<ContainerAllocator> &) { return value(); }
00120 };
00121
00122 template<class ContainerAllocator>
00123 struct Definition< ::camera_self_filter::maskRequest_<ContainerAllocator> > {
00124 static const char* value()
00125 {
00126 return "std_msgs/Header header\n\
00127 \n\
00128 ================================================================================\n\
00129 MSG: std_msgs/Header\n\
00130 # Standard metadata for higher-level stamped data types.\n\
00131 # This is generally used to communicate timestamped data \n\
00132 # in a particular coordinate frame.\n\
00133 # \n\
00134 # sequence ID: consecutively increasing ID \n\
00135 uint32 seq\n\
00136 #Two-integer timestamp that is expressed as:\n\
00137 # * stamp.secs: seconds (stamp_secs) since epoch\n\
00138 # * stamp.nsecs: nanoseconds since stamp_secs\n\
00139 # time-handling sugar is provided by the client library\n\
00140 time stamp\n\
00141 #Frame this data is associated with\n\
00142 # 0: no frame\n\
00143 # 1: global frame\n\
00144 string frame_id\n\
00145 \n\
00146 ";
00147 }
00148
00149 static const char* value(const ::camera_self_filter::maskRequest_<ContainerAllocator> &) { return value(); }
00150 };
00151
00152 }
00153 }
00154
00155
00156 namespace ros
00157 {
00158 namespace message_traits
00159 {
00160 template<class ContainerAllocator> struct IsMessage< ::camera_self_filter::maskResponse_<ContainerAllocator> > : public TrueType {};
00161 template<class ContainerAllocator> struct IsMessage< ::camera_self_filter::maskResponse_<ContainerAllocator> const> : public TrueType {};
00162 template<class ContainerAllocator>
00163 struct MD5Sum< ::camera_self_filter::maskResponse_<ContainerAllocator> > {
00164 static const char* value()
00165 {
00166 return "39c74c093fa8b7c6d397ed7cbe6ce11f";
00167 }
00168
00169 static const char* value(const ::camera_self_filter::maskResponse_<ContainerAllocator> &) { return value(); }
00170 static const uint64_t static_value1 = 0x39c74c093fa8b7c6ULL;
00171 static const uint64_t static_value2 = 0xd397ed7cbe6ce11fULL;
00172 };
00173
00174 template<class ContainerAllocator>
00175 struct DataType< ::camera_self_filter::maskResponse_<ContainerAllocator> > {
00176 static const char* value()
00177 {
00178 return "camera_self_filter/maskResponse";
00179 }
00180
00181 static const char* value(const ::camera_self_filter::maskResponse_<ContainerAllocator> &) { return value(); }
00182 };
00183
00184 template<class ContainerAllocator>
00185 struct Definition< ::camera_self_filter::maskResponse_<ContainerAllocator> > {
00186 static const char* value()
00187 {
00188 return "sensor_msgs/Image mask_image\n\
00189 \n\
00190 ================================================================================\n\
00191 MSG: sensor_msgs/Image\n\
00192 # This message contains an uncompressed image\n\
00193 # (0, 0) is at top-left corner of image\n\
00194 #\n\
00195 \n\
00196 Header header # Header timestamp should be acquisition time of image\n\
00197 # Header frame_id should be optical frame of camera\n\
00198 # origin of frame should be optical center of cameara\n\
00199 # +x should point to the right in the image\n\
00200 # +y should point down in the image\n\
00201 # +z should point into to plane of the image\n\
00202 # If the frame_id here and the frame_id of the CameraInfo\n\
00203 # message associated with the image conflict\n\
00204 # the behavior is undefined\n\
00205 \n\
00206 uint32 height # image height, that is, number of rows\n\
00207 uint32 width # image width, that is, number of columns\n\
00208 \n\
00209 # The legal values for encoding are in file src/image_encodings.cpp\n\
00210 # If you want to standardize a new string format, join\n\
00211 # ros-users@lists.sourceforge.net and send an email proposing a new encoding.\n\
00212 \n\
00213 string encoding # Encoding of pixels -- channel meaning, ordering, size\n\
00214 # taken from the list of strings in src/image_encodings.cpp\n\
00215 \n\
00216 uint8 is_bigendian # is this data bigendian?\n\
00217 uint32 step # Full row length in bytes\n\
00218 uint8[] data # actual matrix data, size is (step * rows)\n\
00219 \n\
00220 ================================================================================\n\
00221 MSG: std_msgs/Header\n\
00222 # Standard metadata for higher-level stamped data types.\n\
00223 # This is generally used to communicate timestamped data \n\
00224 # in a particular coordinate frame.\n\
00225 # \n\
00226 # sequence ID: consecutively increasing ID \n\
00227 uint32 seq\n\
00228 #Two-integer timestamp that is expressed as:\n\
00229 # * stamp.secs: seconds (stamp_secs) since epoch\n\
00230 # * stamp.nsecs: nanoseconds since stamp_secs\n\
00231 # time-handling sugar is provided by the client library\n\
00232 time stamp\n\
00233 #Frame this data is associated with\n\
00234 # 0: no frame\n\
00235 # 1: global frame\n\
00236 string frame_id\n\
00237 \n\
00238 ";
00239 }
00240
00241 static const char* value(const ::camera_self_filter::maskResponse_<ContainerAllocator> &) { return value(); }
00242 };
00243
00244 }
00245 }
00246
00247 namespace ros
00248 {
00249 namespace serialization
00250 {
00251
00252 template<class ContainerAllocator> struct Serializer< ::camera_self_filter::maskRequest_<ContainerAllocator> >
00253 {
00254 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00255 {
00256 stream.next(m.header);
00257 }
00258
00259 ROS_DECLARE_ALLINONE_SERIALIZER;
00260 };
00261 }
00262 }
00263
00264
00265 namespace ros
00266 {
00267 namespace serialization
00268 {
00269
00270 template<class ContainerAllocator> struct Serializer< ::camera_self_filter::maskResponse_<ContainerAllocator> >
00271 {
00272 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00273 {
00274 stream.next(m.mask_image);
00275 }
00276
00277 ROS_DECLARE_ALLINONE_SERIALIZER;
00278 };
00279 }
00280 }
00281
00282 namespace ros
00283 {
00284 namespace service_traits
00285 {
00286 template<>
00287 struct MD5Sum<camera_self_filter::mask> {
00288 static const char* value()
00289 {
00290 return "b38ab8ce976ae4b6660575f6d4ca1ee4";
00291 }
00292
00293 static const char* value(const camera_self_filter::mask&) { return value(); }
00294 };
00295
00296 template<>
00297 struct DataType<camera_self_filter::mask> {
00298 static const char* value()
00299 {
00300 return "camera_self_filter/mask";
00301 }
00302
00303 static const char* value(const camera_self_filter::mask&) { return value(); }
00304 };
00305
00306 template<class ContainerAllocator>
00307 struct MD5Sum<camera_self_filter::maskRequest_<ContainerAllocator> > {
00308 static const char* value()
00309 {
00310 return "b38ab8ce976ae4b6660575f6d4ca1ee4";
00311 }
00312
00313 static const char* value(const camera_self_filter::maskRequest_<ContainerAllocator> &) { return value(); }
00314 };
00315
00316 template<class ContainerAllocator>
00317 struct DataType<camera_self_filter::maskRequest_<ContainerAllocator> > {
00318 static const char* value()
00319 {
00320 return "camera_self_filter/mask";
00321 }
00322
00323 static const char* value(const camera_self_filter::maskRequest_<ContainerAllocator> &) { return value(); }
00324 };
00325
00326 template<class ContainerAllocator>
00327 struct MD5Sum<camera_self_filter::maskResponse_<ContainerAllocator> > {
00328 static const char* value()
00329 {
00330 return "b38ab8ce976ae4b6660575f6d4ca1ee4";
00331 }
00332
00333 static const char* value(const camera_self_filter::maskResponse_<ContainerAllocator> &) { return value(); }
00334 };
00335
00336 template<class ContainerAllocator>
00337 struct DataType<camera_self_filter::maskResponse_<ContainerAllocator> > {
00338 static const char* value()
00339 {
00340 return "camera_self_filter/mask";
00341 }
00342
00343 static const char* value(const camera_self_filter::maskResponse_<ContainerAllocator> &) { return value(); }
00344 };
00345
00346 }
00347 }
00348
00349 #endif // CAMERA_SELF_FILTER_SERVICE_MASK_H
00350