Go to the documentation of this file.00001
00002 #ifndef KINECT_DEPTH_CALIBRATION_SERVICE_GETCHECKERBOARDCENTER_H
00003 #define KINECT_DEPTH_CALIBRATION_SERVICE_GETCHECKERBOARDCENTER_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
00022 namespace kinect_depth_calibration
00023 {
00024 template <class ContainerAllocator>
00025 struct GetCheckerboardCenterRequest_ {
00026 typedef GetCheckerboardCenterRequest_<ContainerAllocator> Type;
00027
00028 GetCheckerboardCenterRequest_()
00029 : min_x(0.0)
00030 , max_x(0.0)
00031 , min_y(0.0)
00032 , max_y(0.0)
00033 , depth_prior(0.0)
00034 {
00035 }
00036
00037 GetCheckerboardCenterRequest_(const ContainerAllocator& _alloc)
00038 : min_x(0.0)
00039 , max_x(0.0)
00040 , min_y(0.0)
00041 , max_y(0.0)
00042 , depth_prior(0.0)
00043 {
00044 }
00045
00046 typedef float _min_x_type;
00047 float min_x;
00048
00049 typedef float _max_x_type;
00050 float max_x;
00051
00052 typedef float _min_y_type;
00053 float min_y;
00054
00055 typedef float _max_y_type;
00056 float max_y;
00057
00058 typedef float _depth_prior_type;
00059 float depth_prior;
00060
00061
00062 typedef boost::shared_ptr< ::kinect_depth_calibration::GetCheckerboardCenterRequest_<ContainerAllocator> > Ptr;
00063 typedef boost::shared_ptr< ::kinect_depth_calibration::GetCheckerboardCenterRequest_<ContainerAllocator> const> ConstPtr;
00064 boost::shared_ptr<std::map<std::string, std::string> > __connection_header;
00065 };
00066 typedef ::kinect_depth_calibration::GetCheckerboardCenterRequest_<std::allocator<void> > GetCheckerboardCenterRequest;
00067
00068 typedef boost::shared_ptr< ::kinect_depth_calibration::GetCheckerboardCenterRequest> GetCheckerboardCenterRequestPtr;
00069 typedef boost::shared_ptr< ::kinect_depth_calibration::GetCheckerboardCenterRequest const> GetCheckerboardCenterRequestConstPtr;
00070
00071
00072 template <class ContainerAllocator>
00073 struct GetCheckerboardCenterResponse_ {
00074 typedef GetCheckerboardCenterResponse_<ContainerAllocator> Type;
00075
00076 GetCheckerboardCenterResponse_()
00077 : depth(0.0)
00078 {
00079 }
00080
00081 GetCheckerboardCenterResponse_(const ContainerAllocator& _alloc)
00082 : depth(0.0)
00083 {
00084 }
00085
00086 typedef float _depth_type;
00087 float depth;
00088
00089
00090 typedef boost::shared_ptr< ::kinect_depth_calibration::GetCheckerboardCenterResponse_<ContainerAllocator> > Ptr;
00091 typedef boost::shared_ptr< ::kinect_depth_calibration::GetCheckerboardCenterResponse_<ContainerAllocator> const> ConstPtr;
00092 boost::shared_ptr<std::map<std::string, std::string> > __connection_header;
00093 };
00094 typedef ::kinect_depth_calibration::GetCheckerboardCenterResponse_<std::allocator<void> > GetCheckerboardCenterResponse;
00095
00096 typedef boost::shared_ptr< ::kinect_depth_calibration::GetCheckerboardCenterResponse> GetCheckerboardCenterResponsePtr;
00097 typedef boost::shared_ptr< ::kinect_depth_calibration::GetCheckerboardCenterResponse const> GetCheckerboardCenterResponseConstPtr;
00098
00099 struct GetCheckerboardCenter
00100 {
00101
00102 typedef GetCheckerboardCenterRequest Request;
00103 typedef GetCheckerboardCenterResponse Response;
00104 Request request;
00105 Response response;
00106
00107 typedef Request RequestType;
00108 typedef Response ResponseType;
00109 };
00110 }
00111
00112 namespace ros
00113 {
00114 namespace message_traits
00115 {
00116 template<class ContainerAllocator> struct IsMessage< ::kinect_depth_calibration::GetCheckerboardCenterRequest_<ContainerAllocator> > : public TrueType {};
00117 template<class ContainerAllocator> struct IsMessage< ::kinect_depth_calibration::GetCheckerboardCenterRequest_<ContainerAllocator> const> : public TrueType {};
00118 template<class ContainerAllocator>
00119 struct MD5Sum< ::kinect_depth_calibration::GetCheckerboardCenterRequest_<ContainerAllocator> > {
00120 static const char* value()
00121 {
00122 return "cb32cbfa86e51d8153cc69cc05343fdf";
00123 }
00124
00125 static const char* value(const ::kinect_depth_calibration::GetCheckerboardCenterRequest_<ContainerAllocator> &) { return value(); }
00126 static const uint64_t static_value1 = 0xcb32cbfa86e51d81ULL;
00127 static const uint64_t static_value2 = 0x53cc69cc05343fdfULL;
00128 };
00129
00130 template<class ContainerAllocator>
00131 struct DataType< ::kinect_depth_calibration::GetCheckerboardCenterRequest_<ContainerAllocator> > {
00132 static const char* value()
00133 {
00134 return "kinect_depth_calibration/GetCheckerboardCenterRequest";
00135 }
00136
00137 static const char* value(const ::kinect_depth_calibration::GetCheckerboardCenterRequest_<ContainerAllocator> &) { return value(); }
00138 };
00139
00140 template<class ContainerAllocator>
00141 struct Definition< ::kinect_depth_calibration::GetCheckerboardCenterRequest_<ContainerAllocator> > {
00142 static const char* value()
00143 {
00144 return "float32 min_x\n\
00145 float32 max_x\n\
00146 float32 min_y\n\
00147 float32 max_y\n\
00148 float32 depth_prior\n\
00149 \n\
00150 ";
00151 }
00152
00153 static const char* value(const ::kinect_depth_calibration::GetCheckerboardCenterRequest_<ContainerAllocator> &) { return value(); }
00154 };
00155
00156 template<class ContainerAllocator> struct IsFixedSize< ::kinect_depth_calibration::GetCheckerboardCenterRequest_<ContainerAllocator> > : public TrueType {};
00157 }
00158 }
00159
00160
00161 namespace ros
00162 {
00163 namespace message_traits
00164 {
00165 template<class ContainerAllocator> struct IsMessage< ::kinect_depth_calibration::GetCheckerboardCenterResponse_<ContainerAllocator> > : public TrueType {};
00166 template<class ContainerAllocator> struct IsMessage< ::kinect_depth_calibration::GetCheckerboardCenterResponse_<ContainerAllocator> const> : public TrueType {};
00167 template<class ContainerAllocator>
00168 struct MD5Sum< ::kinect_depth_calibration::GetCheckerboardCenterResponse_<ContainerAllocator> > {
00169 static const char* value()
00170 {
00171 return "6deb06b7b7183f5581b3362a0cb413b7";
00172 }
00173
00174 static const char* value(const ::kinect_depth_calibration::GetCheckerboardCenterResponse_<ContainerAllocator> &) { return value(); }
00175 static const uint64_t static_value1 = 0x6deb06b7b7183f55ULL;
00176 static const uint64_t static_value2 = 0x81b3362a0cb413b7ULL;
00177 };
00178
00179 template<class ContainerAllocator>
00180 struct DataType< ::kinect_depth_calibration::GetCheckerboardCenterResponse_<ContainerAllocator> > {
00181 static const char* value()
00182 {
00183 return "kinect_depth_calibration/GetCheckerboardCenterResponse";
00184 }
00185
00186 static const char* value(const ::kinect_depth_calibration::GetCheckerboardCenterResponse_<ContainerAllocator> &) { return value(); }
00187 };
00188
00189 template<class ContainerAllocator>
00190 struct Definition< ::kinect_depth_calibration::GetCheckerboardCenterResponse_<ContainerAllocator> > {
00191 static const char* value()
00192 {
00193 return "float32 depth\n\
00194 \n\
00195 \n\
00196 \n\
00197 ";
00198 }
00199
00200 static const char* value(const ::kinect_depth_calibration::GetCheckerboardCenterResponse_<ContainerAllocator> &) { return value(); }
00201 };
00202
00203 template<class ContainerAllocator> struct IsFixedSize< ::kinect_depth_calibration::GetCheckerboardCenterResponse_<ContainerAllocator> > : public TrueType {};
00204 }
00205 }
00206
00207 namespace ros
00208 {
00209 namespace serialization
00210 {
00211
00212 template<class ContainerAllocator> struct Serializer< ::kinect_depth_calibration::GetCheckerboardCenterRequest_<ContainerAllocator> >
00213 {
00214 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00215 {
00216 stream.next(m.min_x);
00217 stream.next(m.max_x);
00218 stream.next(m.min_y);
00219 stream.next(m.max_y);
00220 stream.next(m.depth_prior);
00221 }
00222
00223 ROS_DECLARE_ALLINONE_SERIALIZER;
00224 };
00225 }
00226 }
00227
00228
00229 namespace ros
00230 {
00231 namespace serialization
00232 {
00233
00234 template<class ContainerAllocator> struct Serializer< ::kinect_depth_calibration::GetCheckerboardCenterResponse_<ContainerAllocator> >
00235 {
00236 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00237 {
00238 stream.next(m.depth);
00239 }
00240
00241 ROS_DECLARE_ALLINONE_SERIALIZER;
00242 };
00243 }
00244 }
00245
00246 namespace ros
00247 {
00248 namespace service_traits
00249 {
00250 template<>
00251 struct MD5Sum<kinect_depth_calibration::GetCheckerboardCenter> {
00252 static const char* value()
00253 {
00254 return "1f713d495aa6446fb95738e3ba579737";
00255 }
00256
00257 static const char* value(const kinect_depth_calibration::GetCheckerboardCenter&) { return value(); }
00258 };
00259
00260 template<>
00261 struct DataType<kinect_depth_calibration::GetCheckerboardCenter> {
00262 static const char* value()
00263 {
00264 return "kinect_depth_calibration/GetCheckerboardCenter";
00265 }
00266
00267 static const char* value(const kinect_depth_calibration::GetCheckerboardCenter&) { return value(); }
00268 };
00269
00270 template<class ContainerAllocator>
00271 struct MD5Sum<kinect_depth_calibration::GetCheckerboardCenterRequest_<ContainerAllocator> > {
00272 static const char* value()
00273 {
00274 return "1f713d495aa6446fb95738e3ba579737";
00275 }
00276
00277 static const char* value(const kinect_depth_calibration::GetCheckerboardCenterRequest_<ContainerAllocator> &) { return value(); }
00278 };
00279
00280 template<class ContainerAllocator>
00281 struct DataType<kinect_depth_calibration::GetCheckerboardCenterRequest_<ContainerAllocator> > {
00282 static const char* value()
00283 {
00284 return "kinect_depth_calibration/GetCheckerboardCenter";
00285 }
00286
00287 static const char* value(const kinect_depth_calibration::GetCheckerboardCenterRequest_<ContainerAllocator> &) { return value(); }
00288 };
00289
00290 template<class ContainerAllocator>
00291 struct MD5Sum<kinect_depth_calibration::GetCheckerboardCenterResponse_<ContainerAllocator> > {
00292 static const char* value()
00293 {
00294 return "1f713d495aa6446fb95738e3ba579737";
00295 }
00296
00297 static const char* value(const kinect_depth_calibration::GetCheckerboardCenterResponse_<ContainerAllocator> &) { return value(); }
00298 };
00299
00300 template<class ContainerAllocator>
00301 struct DataType<kinect_depth_calibration::GetCheckerboardCenterResponse_<ContainerAllocator> > {
00302 static const char* value()
00303 {
00304 return "kinect_depth_calibration/GetCheckerboardCenter";
00305 }
00306
00307 static const char* value(const kinect_depth_calibration::GetCheckerboardCenterResponse_<ContainerAllocator> &) { return value(); }
00308 };
00309
00310 }
00311 }
00312
00313 #endif // KINECT_DEPTH_CALIBRATION_SERVICE_GETCHECKERBOARDCENTER_H
00314