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