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 <ostream>
00007 #include "ros/serialization.h"
00008 #include "ros/builtin_message_traits.h"
00009 #include "ros/message_operations.h"
00010 #include "ros/message.h"
00011 #include "ros/time.h"
00012
00013 #include "ros/service_traits.h"
00014
00015 #include "std_msgs/Header.h"
00016
00017
00018 #include "sensor_msgs/Image.h"
00019
00020 namespace camera_self_filter
00021 {
00022 template <class ContainerAllocator>
00023 struct maskRequest_ : public ros::Message
00024 {
00025 typedef maskRequest_<ContainerAllocator> Type;
00026
00027 maskRequest_()
00028 : header()
00029 {
00030 }
00031
00032 maskRequest_(const ContainerAllocator& _alloc)
00033 : header(_alloc)
00034 {
00035 }
00036
00037 typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
00038 ::std_msgs::Header_<ContainerAllocator> header;
00039
00040
00041 private:
00042 static const char* __s_getDataType_() { return "camera_self_filter/maskRequest"; }
00043 public:
00044 ROS_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }
00045
00046 ROS_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }
00047
00048 private:
00049 static const char* __s_getMD5Sum_() { return "d7be0bb39af8fb9129d5a76e6b63a290"; }
00050 public:
00051 ROS_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
00052
00053 ROS_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
00054
00055 private:
00056 static const char* __s_getServerMD5Sum_() { return "b38ab8ce976ae4b6660575f6d4ca1ee4"; }
00057 public:
00058 ROS_DEPRECATED static const std::string __s_getServerMD5Sum() { return __s_getServerMD5Sum_(); }
00059
00060 ROS_DEPRECATED const std::string __getServerMD5Sum() const { return __s_getServerMD5Sum_(); }
00061
00062 private:
00063 static const char* __s_getMessageDefinition_() { return "Header header\n\
00064 \n\
00065 ================================================================================\n\
00066 MSG: std_msgs/Header\n\
00067 # Standard metadata for higher-level stamped data types.\n\
00068 # This is generally used to communicate timestamped data \n\
00069 # in a particular coordinate frame.\n\
00070 # \n\
00071 # sequence ID: consecutively increasing ID \n\
00072 uint32 seq\n\
00073 #Two-integer timestamp that is expressed as:\n\
00074 # * stamp.secs: seconds (stamp_secs) since epoch\n\
00075 # * stamp.nsecs: nanoseconds since stamp_secs\n\
00076 # time-handling sugar is provided by the client library\n\
00077 time stamp\n\
00078 #Frame this data is associated with\n\
00079 # 0: no frame\n\
00080 # 1: global frame\n\
00081 string frame_id\n\
00082 \n\
00083 "; }
00084 public:
00085 ROS_DEPRECATED static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }
00086
00087 ROS_DEPRECATED const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }
00088
00089 ROS_DEPRECATED virtual uint8_t *serialize(uint8_t *write_ptr, uint32_t seq) const
00090 {
00091 ros::serialization::OStream stream(write_ptr, 1000000000);
00092 ros::serialization::serialize(stream, header);
00093 return stream.getData();
00094 }
00095
00096 ROS_DEPRECATED virtual uint8_t *deserialize(uint8_t *read_ptr)
00097 {
00098 ros::serialization::IStream stream(read_ptr, 1000000000);
00099 ros::serialization::deserialize(stream, header);
00100 return stream.getData();
00101 }
00102
00103 ROS_DEPRECATED virtual uint32_t serializationLength() const
00104 {
00105 uint32_t size = 0;
00106 size += ros::serialization::serializationLength(header);
00107 return size;
00108 }
00109
00110 typedef boost::shared_ptr< ::camera_self_filter::maskRequest_<ContainerAllocator> > Ptr;
00111 typedef boost::shared_ptr< ::camera_self_filter::maskRequest_<ContainerAllocator> const> ConstPtr;
00112 };
00113 typedef ::camera_self_filter::maskRequest_<std::allocator<void> > maskRequest;
00114
00115 typedef boost::shared_ptr< ::camera_self_filter::maskRequest> maskRequestPtr;
00116 typedef boost::shared_ptr< ::camera_self_filter::maskRequest const> maskRequestConstPtr;
00117
00118
00119 template <class ContainerAllocator>
00120 struct maskResponse_ : public ros::Message
00121 {
00122 typedef maskResponse_<ContainerAllocator> Type;
00123
00124 maskResponse_()
00125 : mask_image()
00126 {
00127 }
00128
00129 maskResponse_(const ContainerAllocator& _alloc)
00130 : mask_image(_alloc)
00131 {
00132 }
00133
00134 typedef ::sensor_msgs::Image_<ContainerAllocator> _mask_image_type;
00135 ::sensor_msgs::Image_<ContainerAllocator> mask_image;
00136
00137
00138 private:
00139 static const char* __s_getDataType_() { return "camera_self_filter/maskResponse"; }
00140 public:
00141 ROS_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }
00142
00143 ROS_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }
00144
00145 private:
00146 static const char* __s_getMD5Sum_() { return "39c74c093fa8b7c6d397ed7cbe6ce11f"; }
00147 public:
00148 ROS_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
00149
00150 ROS_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
00151
00152 private:
00153 static const char* __s_getServerMD5Sum_() { return "b38ab8ce976ae4b6660575f6d4ca1ee4"; }
00154 public:
00155 ROS_DEPRECATED static const std::string __s_getServerMD5Sum() { return __s_getServerMD5Sum_(); }
00156
00157 ROS_DEPRECATED const std::string __getServerMD5Sum() const { return __s_getServerMD5Sum_(); }
00158
00159 private:
00160 static const char* __s_getMessageDefinition_() { return "sensor_msgs/Image mask_image\n\
00161 \n\
00162 ================================================================================\n\
00163 MSG: sensor_msgs/Image\n\
00164 # This message contains an uncompressed image\n\
00165 # (0, 0) is at top-left corner of image\n\
00166 #\n\
00167 \n\
00168 Header header # Header timestamp should be acquisition time of image\n\
00169 # Header frame_id should be optical frame of camera\n\
00170 # origin of frame should be optical center of cameara\n\
00171 # +x should point to the right in the image\n\
00172 # +y should point down in the image\n\
00173 # +z should point into to plane of the image\n\
00174 # If the frame_id here and the frame_id of the CameraInfo\n\
00175 # message associated with the image conflict\n\
00176 # the behavior is undefined\n\
00177 \n\
00178 uint32 height # image height, that is, number of rows\n\
00179 uint32 width # image width, that is, number of columns\n\
00180 \n\
00181 # The legal values for encoding are in file src/image_encodings.cpp\n\
00182 # If you want to standardize a new string format, join\n\
00183 # ros-users@lists.sourceforge.net and send an email proposing a new encoding.\n\
00184 \n\
00185 string encoding # Encoding of pixels -- channel meaning, ordering, size\n\
00186 # taken from the list of strings in src/image_encodings.cpp\n\
00187 \n\
00188 uint8 is_bigendian # is this data bigendian?\n\
00189 uint32 step # Full row length in bytes\n\
00190 uint8[] data # actual matrix data, size is (step * rows)\n\
00191 \n\
00192 ================================================================================\n\
00193 MSG: std_msgs/Header\n\
00194 # Standard metadata for higher-level stamped data types.\n\
00195 # This is generally used to communicate timestamped data \n\
00196 # in a particular coordinate frame.\n\
00197 # \n\
00198 # sequence ID: consecutively increasing ID \n\
00199 uint32 seq\n\
00200 #Two-integer timestamp that is expressed as:\n\
00201 # * stamp.secs: seconds (stamp_secs) since epoch\n\
00202 # * stamp.nsecs: nanoseconds since stamp_secs\n\
00203 # time-handling sugar is provided by the client library\n\
00204 time stamp\n\
00205 #Frame this data is associated with\n\
00206 # 0: no frame\n\
00207 # 1: global frame\n\
00208 string frame_id\n\
00209 \n\
00210 "; }
00211 public:
00212 ROS_DEPRECATED static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }
00213
00214 ROS_DEPRECATED const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }
00215
00216 ROS_DEPRECATED virtual uint8_t *serialize(uint8_t *write_ptr, uint32_t seq) const
00217 {
00218 ros::serialization::OStream stream(write_ptr, 1000000000);
00219 ros::serialization::serialize(stream, mask_image);
00220 return stream.getData();
00221 }
00222
00223 ROS_DEPRECATED virtual uint8_t *deserialize(uint8_t *read_ptr)
00224 {
00225 ros::serialization::IStream stream(read_ptr, 1000000000);
00226 ros::serialization::deserialize(stream, mask_image);
00227 return stream.getData();
00228 }
00229
00230 ROS_DEPRECATED virtual uint32_t serializationLength() const
00231 {
00232 uint32_t size = 0;
00233 size += ros::serialization::serializationLength(mask_image);
00234 return size;
00235 }
00236
00237 typedef boost::shared_ptr< ::camera_self_filter::maskResponse_<ContainerAllocator> > Ptr;
00238 typedef boost::shared_ptr< ::camera_self_filter::maskResponse_<ContainerAllocator> const> ConstPtr;
00239 };
00240 typedef ::camera_self_filter::maskResponse_<std::allocator<void> > maskResponse;
00241
00242 typedef boost::shared_ptr< ::camera_self_filter::maskResponse> maskResponsePtr;
00243 typedef boost::shared_ptr< ::camera_self_filter::maskResponse const> maskResponseConstPtr;
00244
00245 struct mask
00246 {
00247
00248 typedef maskRequest Request;
00249 typedef maskResponse Response;
00250 Request request;
00251 Response response;
00252
00253 typedef Request RequestType;
00254 typedef Response ResponseType;
00255 };
00256 }
00257
00258 namespace ros
00259 {
00260 namespace message_traits
00261 {
00262 template<class ContainerAllocator>
00263 struct MD5Sum< ::camera_self_filter::maskRequest_<ContainerAllocator> > {
00264 static const char* value()
00265 {
00266 return "d7be0bb39af8fb9129d5a76e6b63a290";
00267 }
00268
00269 static const char* value(const ::camera_self_filter::maskRequest_<ContainerAllocator> &) { return value(); }
00270 static const uint64_t static_value1 = 0xd7be0bb39af8fb91ULL;
00271 static const uint64_t static_value2 = 0x29d5a76e6b63a290ULL;
00272 };
00273
00274 template<class ContainerAllocator>
00275 struct DataType< ::camera_self_filter::maskRequest_<ContainerAllocator> > {
00276 static const char* value()
00277 {
00278 return "camera_self_filter/maskRequest";
00279 }
00280
00281 static const char* value(const ::camera_self_filter::maskRequest_<ContainerAllocator> &) { return value(); }
00282 };
00283
00284 template<class ContainerAllocator>
00285 struct Definition< ::camera_self_filter::maskRequest_<ContainerAllocator> > {
00286 static const char* value()
00287 {
00288 return "Header header\n\
00289 \n\
00290 ================================================================================\n\
00291 MSG: std_msgs/Header\n\
00292 # Standard metadata for higher-level stamped data types.\n\
00293 # This is generally used to communicate timestamped data \n\
00294 # in a particular coordinate frame.\n\
00295 # \n\
00296 # sequence ID: consecutively increasing ID \n\
00297 uint32 seq\n\
00298 #Two-integer timestamp that is expressed as:\n\
00299 # * stamp.secs: seconds (stamp_secs) since epoch\n\
00300 # * stamp.nsecs: nanoseconds since stamp_secs\n\
00301 # time-handling sugar is provided by the client library\n\
00302 time stamp\n\
00303 #Frame this data is associated with\n\
00304 # 0: no frame\n\
00305 # 1: global frame\n\
00306 string frame_id\n\
00307 \n\
00308 ";
00309 }
00310
00311 static const char* value(const ::camera_self_filter::maskRequest_<ContainerAllocator> &) { return value(); }
00312 };
00313
00314 template<class ContainerAllocator> struct HasHeader< ::camera_self_filter::maskRequest_<ContainerAllocator> > : public TrueType {};
00315 template<class ContainerAllocator> struct HasHeader< const ::camera_self_filter::maskRequest_<ContainerAllocator> > : public TrueType {};
00316 }
00317 }
00318
00319
00320 namespace ros
00321 {
00322 namespace message_traits
00323 {
00324 template<class ContainerAllocator>
00325 struct MD5Sum< ::camera_self_filter::maskResponse_<ContainerAllocator> > {
00326 static const char* value()
00327 {
00328 return "39c74c093fa8b7c6d397ed7cbe6ce11f";
00329 }
00330
00331 static const char* value(const ::camera_self_filter::maskResponse_<ContainerAllocator> &) { return value(); }
00332 static const uint64_t static_value1 = 0x39c74c093fa8b7c6ULL;
00333 static const uint64_t static_value2 = 0xd397ed7cbe6ce11fULL;
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/maskResponse";
00341 }
00342
00343 static const char* value(const ::camera_self_filter::maskResponse_<ContainerAllocator> &) { return value(); }
00344 };
00345
00346 template<class ContainerAllocator>
00347 struct Definition< ::camera_self_filter::maskResponse_<ContainerAllocator> > {
00348 static const char* value()
00349 {
00350 return "sensor_msgs/Image mask_image\n\
00351 \n\
00352 ================================================================================\n\
00353 MSG: sensor_msgs/Image\n\
00354 # This message contains an uncompressed image\n\
00355 # (0, 0) is at top-left corner of image\n\
00356 #\n\
00357 \n\
00358 Header header # Header timestamp should be acquisition time of image\n\
00359 # Header frame_id should be optical frame of camera\n\
00360 # origin of frame should be optical center of cameara\n\
00361 # +x should point to the right in the image\n\
00362 # +y should point down in the image\n\
00363 # +z should point into to plane of the image\n\
00364 # If the frame_id here and the frame_id of the CameraInfo\n\
00365 # message associated with the image conflict\n\
00366 # the behavior is undefined\n\
00367 \n\
00368 uint32 height # image height, that is, number of rows\n\
00369 uint32 width # image width, that is, number of columns\n\
00370 \n\
00371 # The legal values for encoding are in file src/image_encodings.cpp\n\
00372 # If you want to standardize a new string format, join\n\
00373 # ros-users@lists.sourceforge.net and send an email proposing a new encoding.\n\
00374 \n\
00375 string encoding # Encoding of pixels -- channel meaning, ordering, size\n\
00376 # taken from the list of strings in src/image_encodings.cpp\n\
00377 \n\
00378 uint8 is_bigendian # is this data bigendian?\n\
00379 uint32 step # Full row length in bytes\n\
00380 uint8[] data # actual matrix data, size is (step * rows)\n\
00381 \n\
00382 ================================================================================\n\
00383 MSG: std_msgs/Header\n\
00384 # Standard metadata for higher-level stamped data types.\n\
00385 # This is generally used to communicate timestamped data \n\
00386 # in a particular coordinate frame.\n\
00387 # \n\
00388 # sequence ID: consecutively increasing ID \n\
00389 uint32 seq\n\
00390 #Two-integer timestamp that is expressed as:\n\
00391 # * stamp.secs: seconds (stamp_secs) since epoch\n\
00392 # * stamp.nsecs: nanoseconds since stamp_secs\n\
00393 # time-handling sugar is provided by the client library\n\
00394 time stamp\n\
00395 #Frame this data is associated with\n\
00396 # 0: no frame\n\
00397 # 1: global frame\n\
00398 string frame_id\n\
00399 \n\
00400 ";
00401 }
00402
00403 static const char* value(const ::camera_self_filter::maskResponse_<ContainerAllocator> &) { return value(); }
00404 };
00405
00406 }
00407 }
00408
00409 namespace ros
00410 {
00411 namespace serialization
00412 {
00413
00414 template<class ContainerAllocator> struct Serializer< ::camera_self_filter::maskRequest_<ContainerAllocator> >
00415 {
00416 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00417 {
00418 stream.next(m.header);
00419 }
00420
00421 ROS_DECLARE_ALLINONE_SERIALIZER;
00422 };
00423 }
00424 }
00425
00426
00427 namespace ros
00428 {
00429 namespace serialization
00430 {
00431
00432 template<class ContainerAllocator> struct Serializer< ::camera_self_filter::maskResponse_<ContainerAllocator> >
00433 {
00434 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00435 {
00436 stream.next(m.mask_image);
00437 }
00438
00439 ROS_DECLARE_ALLINONE_SERIALIZER;
00440 };
00441 }
00442 }
00443
00444 namespace ros
00445 {
00446 namespace service_traits
00447 {
00448 template<>
00449 struct MD5Sum<camera_self_filter::mask> {
00450 static const char* value()
00451 {
00452 return "b38ab8ce976ae4b6660575f6d4ca1ee4";
00453 }
00454
00455 static const char* value(const camera_self_filter::mask&) { return value(); }
00456 };
00457
00458 template<>
00459 struct DataType<camera_self_filter::mask> {
00460 static const char* value()
00461 {
00462 return "camera_self_filter/mask";
00463 }
00464
00465 static const char* value(const camera_self_filter::mask&) { return value(); }
00466 };
00467
00468 template<class ContainerAllocator>
00469 struct MD5Sum<camera_self_filter::maskRequest_<ContainerAllocator> > {
00470 static const char* value()
00471 {
00472 return "b38ab8ce976ae4b6660575f6d4ca1ee4";
00473 }
00474
00475 static const char* value(const camera_self_filter::maskRequest_<ContainerAllocator> &) { return value(); }
00476 };
00477
00478 template<class ContainerAllocator>
00479 struct DataType<camera_self_filter::maskRequest_<ContainerAllocator> > {
00480 static const char* value()
00481 {
00482 return "camera_self_filter/mask";
00483 }
00484
00485 static const char* value(const camera_self_filter::maskRequest_<ContainerAllocator> &) { return value(); }
00486 };
00487
00488 template<class ContainerAllocator>
00489 struct MD5Sum<camera_self_filter::maskResponse_<ContainerAllocator> > {
00490 static const char* value()
00491 {
00492 return "b38ab8ce976ae4b6660575f6d4ca1ee4";
00493 }
00494
00495 static const char* value(const camera_self_filter::maskResponse_<ContainerAllocator> &) { return value(); }
00496 };
00497
00498 template<class ContainerAllocator>
00499 struct DataType<camera_self_filter::maskResponse_<ContainerAllocator> > {
00500 static const char* value()
00501 {
00502 return "camera_self_filter/mask";
00503 }
00504
00505 static const char* value(const camera_self_filter::maskResponse_<ContainerAllocator> &) { return value(); }
00506 };
00507
00508 }
00509 }
00510
00511 #endif // CAMERA_SELF_FILTER_SERVICE_MASK_H
00512