00001
00002 #ifndef PR2_INTERACTIVE_SEGMENTATION_SERVICE_COMPUTEICP_H
00003 #define PR2_INTERACTIVE_SEGMENTATION_SERVICE_COMPUTEICP_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 "sensor_msgs/PointCloud2.h"
00020 #include "sensor_msgs/PointCloud2.h"
00021
00022
00023 #include "geometry_msgs/Pose.h"
00024
00025 namespace pr2_interactive_segmentation
00026 {
00027 template <class ContainerAllocator>
00028 struct computeICPRequest_ {
00029 typedef computeICPRequest_<ContainerAllocator> Type;
00030
00031 computeICPRequest_()
00032 : input()
00033 , target()
00034 {
00035 }
00036
00037 computeICPRequest_(const ContainerAllocator& _alloc)
00038 : input(_alloc)
00039 , target(_alloc)
00040 {
00041 }
00042
00043 typedef ::sensor_msgs::PointCloud2_<ContainerAllocator> _input_type;
00044 ::sensor_msgs::PointCloud2_<ContainerAllocator> input;
00045
00046 typedef ::sensor_msgs::PointCloud2_<ContainerAllocator> _target_type;
00047 ::sensor_msgs::PointCloud2_<ContainerAllocator> target;
00048
00049
00050 private:
00051 static const char* __s_getDataType_() { return "pr2_interactive_segmentation/computeICPRequest"; }
00052 public:
00053 ROS_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }
00054
00055 ROS_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }
00056
00057 private:
00058 static const char* __s_getMD5Sum_() { return "bde9f0d1dd90eb818a6b9512db3750d3"; }
00059 public:
00060 ROS_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
00061
00062 ROS_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
00063
00064 private:
00065 static const char* __s_getServerMD5Sum_() { return "5202812facca6cd2d14b2d6bd8203e30"; }
00066 public:
00067 ROS_DEPRECATED static const std::string __s_getServerMD5Sum() { return __s_getServerMD5Sum_(); }
00068
00069 ROS_DEPRECATED const std::string __getServerMD5Sum() const { return __s_getServerMD5Sum_(); }
00070
00071 private:
00072 static const char* __s_getMessageDefinition_() { return "sensor_msgs/PointCloud2 input\n\
00073 sensor_msgs/PointCloud2 target\n\
00074 \n\
00075 ================================================================================\n\
00076 MSG: sensor_msgs/PointCloud2\n\
00077 # This message holds a collection of N-dimensional points, which may\n\
00078 # contain additional information such as normals, intensity, etc. The\n\
00079 # point data is stored as a binary blob, its layout described by the\n\
00080 # contents of the \"fields\" array.\n\
00081 \n\
00082 # The point cloud data may be organized 2d (image-like) or 1d\n\
00083 # (unordered). Point clouds organized as 2d images may be produced by\n\
00084 # camera depth sensors such as stereo or time-of-flight.\n\
00085 \n\
00086 # Time of sensor data acquisition, and the coordinate frame ID (for 3d\n\
00087 # points).\n\
00088 Header header\n\
00089 \n\
00090 # 2D structure of the point cloud. If the cloud is unordered, height is\n\
00091 # 1 and width is the length of the point cloud.\n\
00092 uint32 height\n\
00093 uint32 width\n\
00094 \n\
00095 # Describes the channels and their layout in the binary data blob.\n\
00096 PointField[] fields\n\
00097 \n\
00098 bool is_bigendian # Is this data bigendian?\n\
00099 uint32 point_step # Length of a point in bytes\n\
00100 uint32 row_step # Length of a row in bytes\n\
00101 uint8[] data # Actual point data, size is (row_step*height)\n\
00102 \n\
00103 bool is_dense # True if there are no invalid points\n\
00104 \n\
00105 ================================================================================\n\
00106 MSG: std_msgs/Header\n\
00107 # Standard metadata for higher-level stamped data types.\n\
00108 # This is generally used to communicate timestamped data \n\
00109 # in a particular coordinate frame.\n\
00110 # \n\
00111 # sequence ID: consecutively increasing ID \n\
00112 uint32 seq\n\
00113 #Two-integer timestamp that is expressed as:\n\
00114 # * stamp.secs: seconds (stamp_secs) since epoch\n\
00115 # * stamp.nsecs: nanoseconds since stamp_secs\n\
00116 # time-handling sugar is provided by the client library\n\
00117 time stamp\n\
00118 #Frame this data is associated with\n\
00119 # 0: no frame\n\
00120 # 1: global frame\n\
00121 string frame_id\n\
00122 \n\
00123 ================================================================================\n\
00124 MSG: sensor_msgs/PointField\n\
00125 # This message holds the description of one point entry in the\n\
00126 # PointCloud2 message format.\n\
00127 uint8 INT8 = 1\n\
00128 uint8 UINT8 = 2\n\
00129 uint8 INT16 = 3\n\
00130 uint8 UINT16 = 4\n\
00131 uint8 INT32 = 5\n\
00132 uint8 UINT32 = 6\n\
00133 uint8 FLOAT32 = 7\n\
00134 uint8 FLOAT64 = 8\n\
00135 \n\
00136 string name # Name of field\n\
00137 uint32 offset # Offset from start of point struct\n\
00138 uint8 datatype # Datatype enumeration, see above\n\
00139 uint32 count # How many elements in the field\n\
00140 \n\
00141 "; }
00142 public:
00143 ROS_DEPRECATED static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }
00144
00145 ROS_DEPRECATED const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }
00146
00147 ROS_DEPRECATED virtual uint8_t *serialize(uint8_t *write_ptr, uint32_t seq) const
00148 {
00149 ros::serialization::OStream stream(write_ptr, 1000000000);
00150 ros::serialization::serialize(stream, input);
00151 ros::serialization::serialize(stream, target);
00152 return stream.getData();
00153 }
00154
00155 ROS_DEPRECATED virtual uint8_t *deserialize(uint8_t *read_ptr)
00156 {
00157 ros::serialization::IStream stream(read_ptr, 1000000000);
00158 ros::serialization::deserialize(stream, input);
00159 ros::serialization::deserialize(stream, target);
00160 return stream.getData();
00161 }
00162
00163 ROS_DEPRECATED virtual uint32_t serializationLength() const
00164 {
00165 uint32_t size = 0;
00166 size += ros::serialization::serializationLength(input);
00167 size += ros::serialization::serializationLength(target);
00168 return size;
00169 }
00170
00171 typedef boost::shared_ptr< ::pr2_interactive_segmentation::computeICPRequest_<ContainerAllocator> > Ptr;
00172 typedef boost::shared_ptr< ::pr2_interactive_segmentation::computeICPRequest_<ContainerAllocator> const> ConstPtr;
00173 boost::shared_ptr<std::map<std::string, std::string> > __connection_header;
00174 };
00175 typedef ::pr2_interactive_segmentation::computeICPRequest_<std::allocator<void> > computeICPRequest;
00176
00177 typedef boost::shared_ptr< ::pr2_interactive_segmentation::computeICPRequest> computeICPRequestPtr;
00178 typedef boost::shared_ptr< ::pr2_interactive_segmentation::computeICPRequest const> computeICPRequestConstPtr;
00179
00180
00181 template <class ContainerAllocator>
00182 struct computeICPResponse_ {
00183 typedef computeICPResponse_<ContainerAllocator> Type;
00184
00185 computeICPResponse_()
00186 : transform()
00187 {
00188 }
00189
00190 computeICPResponse_(const ContainerAllocator& _alloc)
00191 : transform(_alloc)
00192 {
00193 }
00194
00195 typedef ::geometry_msgs::Pose_<ContainerAllocator> _transform_type;
00196 ::geometry_msgs::Pose_<ContainerAllocator> transform;
00197
00198
00199 private:
00200 static const char* __s_getDataType_() { return "pr2_interactive_segmentation/computeICPResponse"; }
00201 public:
00202 ROS_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }
00203
00204 ROS_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }
00205
00206 private:
00207 static const char* __s_getMD5Sum_() { return "6784139f41d477bc9647bd6bd3fb0294"; }
00208 public:
00209 ROS_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
00210
00211 ROS_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
00212
00213 private:
00214 static const char* __s_getServerMD5Sum_() { return "5202812facca6cd2d14b2d6bd8203e30"; }
00215 public:
00216 ROS_DEPRECATED static const std::string __s_getServerMD5Sum() { return __s_getServerMD5Sum_(); }
00217
00218 ROS_DEPRECATED const std::string __getServerMD5Sum() const { return __s_getServerMD5Sum_(); }
00219
00220 private:
00221 static const char* __s_getMessageDefinition_() { return "geometry_msgs/Pose transform\n\
00222 \n\
00223 ================================================================================\n\
00224 MSG: geometry_msgs/Pose\n\
00225 # A representation of pose in free space, composed of postion and orientation. \n\
00226 Point position\n\
00227 Quaternion orientation\n\
00228 \n\
00229 ================================================================================\n\
00230 MSG: geometry_msgs/Point\n\
00231 # This contains the position of a point in free space\n\
00232 float64 x\n\
00233 float64 y\n\
00234 float64 z\n\
00235 \n\
00236 ================================================================================\n\
00237 MSG: geometry_msgs/Quaternion\n\
00238 # This represents an orientation in free space in quaternion form.\n\
00239 \n\
00240 float64 x\n\
00241 float64 y\n\
00242 float64 z\n\
00243 float64 w\n\
00244 \n\
00245 "; }
00246 public:
00247 ROS_DEPRECATED static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }
00248
00249 ROS_DEPRECATED const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }
00250
00251 ROS_DEPRECATED virtual uint8_t *serialize(uint8_t *write_ptr, uint32_t seq) const
00252 {
00253 ros::serialization::OStream stream(write_ptr, 1000000000);
00254 ros::serialization::serialize(stream, transform);
00255 return stream.getData();
00256 }
00257
00258 ROS_DEPRECATED virtual uint8_t *deserialize(uint8_t *read_ptr)
00259 {
00260 ros::serialization::IStream stream(read_ptr, 1000000000);
00261 ros::serialization::deserialize(stream, transform);
00262 return stream.getData();
00263 }
00264
00265 ROS_DEPRECATED virtual uint32_t serializationLength() const
00266 {
00267 uint32_t size = 0;
00268 size += ros::serialization::serializationLength(transform);
00269 return size;
00270 }
00271
00272 typedef boost::shared_ptr< ::pr2_interactive_segmentation::computeICPResponse_<ContainerAllocator> > Ptr;
00273 typedef boost::shared_ptr< ::pr2_interactive_segmentation::computeICPResponse_<ContainerAllocator> const> ConstPtr;
00274 boost::shared_ptr<std::map<std::string, std::string> > __connection_header;
00275 };
00276 typedef ::pr2_interactive_segmentation::computeICPResponse_<std::allocator<void> > computeICPResponse;
00277
00278 typedef boost::shared_ptr< ::pr2_interactive_segmentation::computeICPResponse> computeICPResponsePtr;
00279 typedef boost::shared_ptr< ::pr2_interactive_segmentation::computeICPResponse const> computeICPResponseConstPtr;
00280
00281 struct computeICP
00282 {
00283
00284 typedef computeICPRequest Request;
00285 typedef computeICPResponse Response;
00286 Request request;
00287 Response response;
00288
00289 typedef Request RequestType;
00290 typedef Response ResponseType;
00291 };
00292 }
00293
00294 namespace ros
00295 {
00296 namespace message_traits
00297 {
00298 template<class ContainerAllocator> struct IsMessage< ::pr2_interactive_segmentation::computeICPRequest_<ContainerAllocator> > : public TrueType {};
00299 template<class ContainerAllocator> struct IsMessage< ::pr2_interactive_segmentation::computeICPRequest_<ContainerAllocator> const> : public TrueType {};
00300 template<class ContainerAllocator>
00301 struct MD5Sum< ::pr2_interactive_segmentation::computeICPRequest_<ContainerAllocator> > {
00302 static const char* value()
00303 {
00304 return "bde9f0d1dd90eb818a6b9512db3750d3";
00305 }
00306
00307 static const char* value(const ::pr2_interactive_segmentation::computeICPRequest_<ContainerAllocator> &) { return value(); }
00308 static const uint64_t static_value1 = 0xbde9f0d1dd90eb81ULL;
00309 static const uint64_t static_value2 = 0x8a6b9512db3750d3ULL;
00310 };
00311
00312 template<class ContainerAllocator>
00313 struct DataType< ::pr2_interactive_segmentation::computeICPRequest_<ContainerAllocator> > {
00314 static const char* value()
00315 {
00316 return "pr2_interactive_segmentation/computeICPRequest";
00317 }
00318
00319 static const char* value(const ::pr2_interactive_segmentation::computeICPRequest_<ContainerAllocator> &) { return value(); }
00320 };
00321
00322 template<class ContainerAllocator>
00323 struct Definition< ::pr2_interactive_segmentation::computeICPRequest_<ContainerAllocator> > {
00324 static const char* value()
00325 {
00326 return "sensor_msgs/PointCloud2 input\n\
00327 sensor_msgs/PointCloud2 target\n\
00328 \n\
00329 ================================================================================\n\
00330 MSG: sensor_msgs/PointCloud2\n\
00331 # This message holds a collection of N-dimensional points, which may\n\
00332 # contain additional information such as normals, intensity, etc. The\n\
00333 # point data is stored as a binary blob, its layout described by the\n\
00334 # contents of the \"fields\" array.\n\
00335 \n\
00336 # The point cloud data may be organized 2d (image-like) or 1d\n\
00337 # (unordered). Point clouds organized as 2d images may be produced by\n\
00338 # camera depth sensors such as stereo or time-of-flight.\n\
00339 \n\
00340 # Time of sensor data acquisition, and the coordinate frame ID (for 3d\n\
00341 # points).\n\
00342 Header header\n\
00343 \n\
00344 # 2D structure of the point cloud. If the cloud is unordered, height is\n\
00345 # 1 and width is the length of the point cloud.\n\
00346 uint32 height\n\
00347 uint32 width\n\
00348 \n\
00349 # Describes the channels and their layout in the binary data blob.\n\
00350 PointField[] fields\n\
00351 \n\
00352 bool is_bigendian # Is this data bigendian?\n\
00353 uint32 point_step # Length of a point in bytes\n\
00354 uint32 row_step # Length of a row in bytes\n\
00355 uint8[] data # Actual point data, size is (row_step*height)\n\
00356 \n\
00357 bool is_dense # True if there are no invalid points\n\
00358 \n\
00359 ================================================================================\n\
00360 MSG: std_msgs/Header\n\
00361 # Standard metadata for higher-level stamped data types.\n\
00362 # This is generally used to communicate timestamped data \n\
00363 # in a particular coordinate frame.\n\
00364 # \n\
00365 # sequence ID: consecutively increasing ID \n\
00366 uint32 seq\n\
00367 #Two-integer timestamp that is expressed as:\n\
00368 # * stamp.secs: seconds (stamp_secs) since epoch\n\
00369 # * stamp.nsecs: nanoseconds since stamp_secs\n\
00370 # time-handling sugar is provided by the client library\n\
00371 time stamp\n\
00372 #Frame this data is associated with\n\
00373 # 0: no frame\n\
00374 # 1: global frame\n\
00375 string frame_id\n\
00376 \n\
00377 ================================================================================\n\
00378 MSG: sensor_msgs/PointField\n\
00379 # This message holds the description of one point entry in the\n\
00380 # PointCloud2 message format.\n\
00381 uint8 INT8 = 1\n\
00382 uint8 UINT8 = 2\n\
00383 uint8 INT16 = 3\n\
00384 uint8 UINT16 = 4\n\
00385 uint8 INT32 = 5\n\
00386 uint8 UINT32 = 6\n\
00387 uint8 FLOAT32 = 7\n\
00388 uint8 FLOAT64 = 8\n\
00389 \n\
00390 string name # Name of field\n\
00391 uint32 offset # Offset from start of point struct\n\
00392 uint8 datatype # Datatype enumeration, see above\n\
00393 uint32 count # How many elements in the field\n\
00394 \n\
00395 ";
00396 }
00397
00398 static const char* value(const ::pr2_interactive_segmentation::computeICPRequest_<ContainerAllocator> &) { return value(); }
00399 };
00400
00401 }
00402 }
00403
00404
00405 namespace ros
00406 {
00407 namespace message_traits
00408 {
00409 template<class ContainerAllocator> struct IsMessage< ::pr2_interactive_segmentation::computeICPResponse_<ContainerAllocator> > : public TrueType {};
00410 template<class ContainerAllocator> struct IsMessage< ::pr2_interactive_segmentation::computeICPResponse_<ContainerAllocator> const> : public TrueType {};
00411 template<class ContainerAllocator>
00412 struct MD5Sum< ::pr2_interactive_segmentation::computeICPResponse_<ContainerAllocator> > {
00413 static const char* value()
00414 {
00415 return "6784139f41d477bc9647bd6bd3fb0294";
00416 }
00417
00418 static const char* value(const ::pr2_interactive_segmentation::computeICPResponse_<ContainerAllocator> &) { return value(); }
00419 static const uint64_t static_value1 = 0x6784139f41d477bcULL;
00420 static const uint64_t static_value2 = 0x9647bd6bd3fb0294ULL;
00421 };
00422
00423 template<class ContainerAllocator>
00424 struct DataType< ::pr2_interactive_segmentation::computeICPResponse_<ContainerAllocator> > {
00425 static const char* value()
00426 {
00427 return "pr2_interactive_segmentation/computeICPResponse";
00428 }
00429
00430 static const char* value(const ::pr2_interactive_segmentation::computeICPResponse_<ContainerAllocator> &) { return value(); }
00431 };
00432
00433 template<class ContainerAllocator>
00434 struct Definition< ::pr2_interactive_segmentation::computeICPResponse_<ContainerAllocator> > {
00435 static const char* value()
00436 {
00437 return "geometry_msgs/Pose transform\n\
00438 \n\
00439 ================================================================================\n\
00440 MSG: geometry_msgs/Pose\n\
00441 # A representation of pose in free space, composed of postion and orientation. \n\
00442 Point position\n\
00443 Quaternion orientation\n\
00444 \n\
00445 ================================================================================\n\
00446 MSG: geometry_msgs/Point\n\
00447 # This contains the position of a point in free space\n\
00448 float64 x\n\
00449 float64 y\n\
00450 float64 z\n\
00451 \n\
00452 ================================================================================\n\
00453 MSG: geometry_msgs/Quaternion\n\
00454 # This represents an orientation in free space in quaternion form.\n\
00455 \n\
00456 float64 x\n\
00457 float64 y\n\
00458 float64 z\n\
00459 float64 w\n\
00460 \n\
00461 ";
00462 }
00463
00464 static const char* value(const ::pr2_interactive_segmentation::computeICPResponse_<ContainerAllocator> &) { return value(); }
00465 };
00466
00467 template<class ContainerAllocator> struct IsFixedSize< ::pr2_interactive_segmentation::computeICPResponse_<ContainerAllocator> > : public TrueType {};
00468 }
00469 }
00470
00471 namespace ros
00472 {
00473 namespace serialization
00474 {
00475
00476 template<class ContainerAllocator> struct Serializer< ::pr2_interactive_segmentation::computeICPRequest_<ContainerAllocator> >
00477 {
00478 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00479 {
00480 stream.next(m.input);
00481 stream.next(m.target);
00482 }
00483
00484 ROS_DECLARE_ALLINONE_SERIALIZER;
00485 };
00486 }
00487 }
00488
00489
00490 namespace ros
00491 {
00492 namespace serialization
00493 {
00494
00495 template<class ContainerAllocator> struct Serializer< ::pr2_interactive_segmentation::computeICPResponse_<ContainerAllocator> >
00496 {
00497 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00498 {
00499 stream.next(m.transform);
00500 }
00501
00502 ROS_DECLARE_ALLINONE_SERIALIZER;
00503 };
00504 }
00505 }
00506
00507 namespace ros
00508 {
00509 namespace service_traits
00510 {
00511 template<>
00512 struct MD5Sum<pr2_interactive_segmentation::computeICP> {
00513 static const char* value()
00514 {
00515 return "5202812facca6cd2d14b2d6bd8203e30";
00516 }
00517
00518 static const char* value(const pr2_interactive_segmentation::computeICP&) { return value(); }
00519 };
00520
00521 template<>
00522 struct DataType<pr2_interactive_segmentation::computeICP> {
00523 static const char* value()
00524 {
00525 return "pr2_interactive_segmentation/computeICP";
00526 }
00527
00528 static const char* value(const pr2_interactive_segmentation::computeICP&) { return value(); }
00529 };
00530
00531 template<class ContainerAllocator>
00532 struct MD5Sum<pr2_interactive_segmentation::computeICPRequest_<ContainerAllocator> > {
00533 static const char* value()
00534 {
00535 return "5202812facca6cd2d14b2d6bd8203e30";
00536 }
00537
00538 static const char* value(const pr2_interactive_segmentation::computeICPRequest_<ContainerAllocator> &) { return value(); }
00539 };
00540
00541 template<class ContainerAllocator>
00542 struct DataType<pr2_interactive_segmentation::computeICPRequest_<ContainerAllocator> > {
00543 static const char* value()
00544 {
00545 return "pr2_interactive_segmentation/computeICP";
00546 }
00547
00548 static const char* value(const pr2_interactive_segmentation::computeICPRequest_<ContainerAllocator> &) { return value(); }
00549 };
00550
00551 template<class ContainerAllocator>
00552 struct MD5Sum<pr2_interactive_segmentation::computeICPResponse_<ContainerAllocator> > {
00553 static const char* value()
00554 {
00555 return "5202812facca6cd2d14b2d6bd8203e30";
00556 }
00557
00558 static const char* value(const pr2_interactive_segmentation::computeICPResponse_<ContainerAllocator> &) { return value(); }
00559 };
00560
00561 template<class ContainerAllocator>
00562 struct DataType<pr2_interactive_segmentation::computeICPResponse_<ContainerAllocator> > {
00563 static const char* value()
00564 {
00565 return "pr2_interactive_segmentation/computeICP";
00566 }
00567
00568 static const char* value(const pr2_interactive_segmentation::computeICPResponse_<ContainerAllocator> &) { return value(); }
00569 };
00570
00571 }
00572 }
00573
00574 #endif // PR2_INTERACTIVE_SEGMENTATION_SERVICE_COMPUTEICP_H
00575