Go to the documentation of this file.00001
00002 #ifndef POLLED_CAMERA_SERVICE_GETPOLLEDIMAGE_H
00003 #define POLLED_CAMERA_SERVICE_GETPOLLEDIMAGE_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/RegionOfInterest.h"
00020
00021
00022
00023 namespace polled_camera
00024 {
00025 template <class ContainerAllocator>
00026 struct GetPolledImageRequest_ {
00027 typedef GetPolledImageRequest_<ContainerAllocator> Type;
00028
00029 GetPolledImageRequest_()
00030 : response_namespace()
00031 , timeout()
00032 , binning_x(0)
00033 , binning_y(0)
00034 , roi()
00035 {
00036 }
00037
00038 GetPolledImageRequest_(const ContainerAllocator& _alloc)
00039 : response_namespace(_alloc)
00040 , timeout()
00041 , binning_x(0)
00042 , binning_y(0)
00043 , roi(_alloc)
00044 {
00045 }
00046
00047 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _response_namespace_type;
00048 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > response_namespace;
00049
00050 typedef ros::Duration _timeout_type;
00051 ros::Duration timeout;
00052
00053 typedef uint32_t _binning_x_type;
00054 uint32_t binning_x;
00055
00056 typedef uint32_t _binning_y_type;
00057 uint32_t binning_y;
00058
00059 typedef ::sensor_msgs::RegionOfInterest_<ContainerAllocator> _roi_type;
00060 ::sensor_msgs::RegionOfInterest_<ContainerAllocator> roi;
00061
00062
00063 typedef boost::shared_ptr< ::polled_camera::GetPolledImageRequest_<ContainerAllocator> > Ptr;
00064 typedef boost::shared_ptr< ::polled_camera::GetPolledImageRequest_<ContainerAllocator> const> ConstPtr;
00065 boost::shared_ptr<std::map<std::string, std::string> > __connection_header;
00066 };
00067 typedef ::polled_camera::GetPolledImageRequest_<std::allocator<void> > GetPolledImageRequest;
00068
00069 typedef boost::shared_ptr< ::polled_camera::GetPolledImageRequest> GetPolledImageRequestPtr;
00070 typedef boost::shared_ptr< ::polled_camera::GetPolledImageRequest const> GetPolledImageRequestConstPtr;
00071
00072
00073 template <class ContainerAllocator>
00074 struct GetPolledImageResponse_ {
00075 typedef GetPolledImageResponse_<ContainerAllocator> Type;
00076
00077 GetPolledImageResponse_()
00078 : success(false)
00079 , status_message()
00080 , stamp()
00081 {
00082 }
00083
00084 GetPolledImageResponse_(const ContainerAllocator& _alloc)
00085 : success(false)
00086 , status_message(_alloc)
00087 , stamp()
00088 {
00089 }
00090
00091 typedef uint8_t _success_type;
00092 uint8_t success;
00093
00094 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _status_message_type;
00095 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > status_message;
00096
00097 typedef ros::Time _stamp_type;
00098 ros::Time stamp;
00099
00100
00101 typedef boost::shared_ptr< ::polled_camera::GetPolledImageResponse_<ContainerAllocator> > Ptr;
00102 typedef boost::shared_ptr< ::polled_camera::GetPolledImageResponse_<ContainerAllocator> const> ConstPtr;
00103 boost::shared_ptr<std::map<std::string, std::string> > __connection_header;
00104 };
00105 typedef ::polled_camera::GetPolledImageResponse_<std::allocator<void> > GetPolledImageResponse;
00106
00107 typedef boost::shared_ptr< ::polled_camera::GetPolledImageResponse> GetPolledImageResponsePtr;
00108 typedef boost::shared_ptr< ::polled_camera::GetPolledImageResponse const> GetPolledImageResponseConstPtr;
00109
00110 struct GetPolledImage
00111 {
00112
00113 typedef GetPolledImageRequest Request;
00114 typedef GetPolledImageResponse Response;
00115 Request request;
00116 Response response;
00117
00118 typedef Request RequestType;
00119 typedef Response ResponseType;
00120 };
00121 }
00122
00123 namespace ros
00124 {
00125 namespace message_traits
00126 {
00127 template<class ContainerAllocator> struct IsMessage< ::polled_camera::GetPolledImageRequest_<ContainerAllocator> > : public TrueType {};
00128 template<class ContainerAllocator> struct IsMessage< ::polled_camera::GetPolledImageRequest_<ContainerAllocator> const> : public TrueType {};
00129 template<class ContainerAllocator>
00130 struct MD5Sum< ::polled_camera::GetPolledImageRequest_<ContainerAllocator> > {
00131 static const char* value()
00132 {
00133 return "c77ed43e530fd48e9e7a2a93845e154c";
00134 }
00135
00136 static const char* value(const ::polled_camera::GetPolledImageRequest_<ContainerAllocator> &) { return value(); }
00137 static const uint64_t static_value1 = 0xc77ed43e530fd48eULL;
00138 static const uint64_t static_value2 = 0x9e7a2a93845e154cULL;
00139 };
00140
00141 template<class ContainerAllocator>
00142 struct DataType< ::polled_camera::GetPolledImageRequest_<ContainerAllocator> > {
00143 static const char* value()
00144 {
00145 return "polled_camera/GetPolledImageRequest";
00146 }
00147
00148 static const char* value(const ::polled_camera::GetPolledImageRequest_<ContainerAllocator> &) { return value(); }
00149 };
00150
00151 template<class ContainerAllocator>
00152 struct Definition< ::polled_camera::GetPolledImageRequest_<ContainerAllocator> > {
00153 static const char* value()
00154 {
00155 return "\n\
00156 \n\
00157 \n\
00158 \n\
00159 string response_namespace\n\
00160 \n\
00161 \n\
00162 \n\
00163 \n\
00164 duration timeout\n\
00165 \n\
00166 \n\
00167 uint32 binning_x\n\
00168 uint32 binning_y\n\
00169 \n\
00170 \n\
00171 sensor_msgs/RegionOfInterest roi\n\
00172 \n\
00173 ================================================================================\n\
00174 MSG: sensor_msgs/RegionOfInterest\n\
00175 # This message is used to specify a region of interest within an image.\n\
00176 #\n\
00177 # When used to specify the ROI setting of the camera when the image was\n\
00178 # taken, the height and width fields should either match the height and\n\
00179 # width fields for the associated image; or height = width = 0\n\
00180 # indicates that the full resolution image was captured.\n\
00181 \n\
00182 uint32 x_offset # Leftmost pixel of the ROI\n\
00183 # (0 if the ROI includes the left edge of the image)\n\
00184 uint32 y_offset # Topmost pixel of the ROI\n\
00185 # (0 if the ROI includes the top edge of the image)\n\
00186 uint32 height # Height of ROI\n\
00187 uint32 width # Width of ROI\n\
00188 \n\
00189 # True if a distinct rectified ROI should be calculated from the \"raw\"\n\
00190 # ROI in this message. Typically this should be False if the full image\n\
00191 # is captured (ROI not used), and True if a subwindow is captured (ROI\n\
00192 # used).\n\
00193 bool do_rectify\n\
00194 \n\
00195 ";
00196 }
00197
00198 static const char* value(const ::polled_camera::GetPolledImageRequest_<ContainerAllocator> &) { return value(); }
00199 };
00200
00201 }
00202 }
00203
00204
00205 namespace ros
00206 {
00207 namespace message_traits
00208 {
00209 template<class ContainerAllocator> struct IsMessage< ::polled_camera::GetPolledImageResponse_<ContainerAllocator> > : public TrueType {};
00210 template<class ContainerAllocator> struct IsMessage< ::polled_camera::GetPolledImageResponse_<ContainerAllocator> const> : public TrueType {};
00211 template<class ContainerAllocator>
00212 struct MD5Sum< ::polled_camera::GetPolledImageResponse_<ContainerAllocator> > {
00213 static const char* value()
00214 {
00215 return "dbf1f851bc511800e6129ccd5a3542ab";
00216 }
00217
00218 static const char* value(const ::polled_camera::GetPolledImageResponse_<ContainerAllocator> &) { return value(); }
00219 static const uint64_t static_value1 = 0xdbf1f851bc511800ULL;
00220 static const uint64_t static_value2 = 0xe6129ccd5a3542abULL;
00221 };
00222
00223 template<class ContainerAllocator>
00224 struct DataType< ::polled_camera::GetPolledImageResponse_<ContainerAllocator> > {
00225 static const char* value()
00226 {
00227 return "polled_camera/GetPolledImageResponse";
00228 }
00229
00230 static const char* value(const ::polled_camera::GetPolledImageResponse_<ContainerAllocator> &) { return value(); }
00231 };
00232
00233 template<class ContainerAllocator>
00234 struct Definition< ::polled_camera::GetPolledImageResponse_<ContainerAllocator> > {
00235 static const char* value()
00236 {
00237 return "bool success\n\
00238 string status_message\n\
00239 time stamp\n\
00240 \n\
00241 \n\
00242 \n\
00243 ";
00244 }
00245
00246 static const char* value(const ::polled_camera::GetPolledImageResponse_<ContainerAllocator> &) { return value(); }
00247 };
00248
00249 }
00250 }
00251
00252 namespace ros
00253 {
00254 namespace serialization
00255 {
00256
00257 template<class ContainerAllocator> struct Serializer< ::polled_camera::GetPolledImageRequest_<ContainerAllocator> >
00258 {
00259 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00260 {
00261 stream.next(m.response_namespace);
00262 stream.next(m.timeout);
00263 stream.next(m.binning_x);
00264 stream.next(m.binning_y);
00265 stream.next(m.roi);
00266 }
00267
00268 ROS_DECLARE_ALLINONE_SERIALIZER;
00269 };
00270 }
00271 }
00272
00273
00274 namespace ros
00275 {
00276 namespace serialization
00277 {
00278
00279 template<class ContainerAllocator> struct Serializer< ::polled_camera::GetPolledImageResponse_<ContainerAllocator> >
00280 {
00281 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00282 {
00283 stream.next(m.success);
00284 stream.next(m.status_message);
00285 stream.next(m.stamp);
00286 }
00287
00288 ROS_DECLARE_ALLINONE_SERIALIZER;
00289 };
00290 }
00291 }
00292
00293 namespace ros
00294 {
00295 namespace service_traits
00296 {
00297 template<>
00298 struct MD5Sum<polled_camera::GetPolledImage> {
00299 static const char* value()
00300 {
00301 return "1f3fb0d09d6e1c72d4a7eeb9822d9030";
00302 }
00303
00304 static const char* value(const polled_camera::GetPolledImage&) { return value(); }
00305 };
00306
00307 template<>
00308 struct DataType<polled_camera::GetPolledImage> {
00309 static const char* value()
00310 {
00311 return "polled_camera/GetPolledImage";
00312 }
00313
00314 static const char* value(const polled_camera::GetPolledImage&) { return value(); }
00315 };
00316
00317 template<class ContainerAllocator>
00318 struct MD5Sum<polled_camera::GetPolledImageRequest_<ContainerAllocator> > {
00319 static const char* value()
00320 {
00321 return "1f3fb0d09d6e1c72d4a7eeb9822d9030";
00322 }
00323
00324 static const char* value(const polled_camera::GetPolledImageRequest_<ContainerAllocator> &) { return value(); }
00325 };
00326
00327 template<class ContainerAllocator>
00328 struct DataType<polled_camera::GetPolledImageRequest_<ContainerAllocator> > {
00329 static const char* value()
00330 {
00331 return "polled_camera/GetPolledImage";
00332 }
00333
00334 static const char* value(const polled_camera::GetPolledImageRequest_<ContainerAllocator> &) { return value(); }
00335 };
00336
00337 template<class ContainerAllocator>
00338 struct MD5Sum<polled_camera::GetPolledImageResponse_<ContainerAllocator> > {
00339 static const char* value()
00340 {
00341 return "1f3fb0d09d6e1c72d4a7eeb9822d9030";
00342 }
00343
00344 static const char* value(const polled_camera::GetPolledImageResponse_<ContainerAllocator> &) { return value(); }
00345 };
00346
00347 template<class ContainerAllocator>
00348 struct DataType<polled_camera::GetPolledImageResponse_<ContainerAllocator> > {
00349 static const char* value()
00350 {
00351 return "polled_camera/GetPolledImage";
00352 }
00353
00354 static const char* value(const polled_camera::GetPolledImageResponse_<ContainerAllocator> &) { return value(); }
00355 };
00356
00357 }
00358 }
00359
00360 #endif // POLLED_CAMERA_SERVICE_GETPOLLEDIMAGE_H
00361