00001
00002 #ifndef VIRTUAL_CAMERA_MESSAGE_VIRTUALCAMERAPARAMETERS_H
00003 #define VIRTUAL_CAMERA_MESSAGE_VIRTUALCAMERAPARAMETERS_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
00018 namespace virtual_camera
00019 {
00020 template <class ContainerAllocator>
00021 struct VirtualCameraParameters_ {
00022 typedef VirtualCameraParameters_<ContainerAllocator> Type;
00023
00024 VirtualCameraParameters_()
00025 : approxDistance(0.0)
00026 , viewportWidth(0)
00027 , viewportHeight(0)
00028 , parentFrameId()
00029 , posX(0.0)
00030 , posY(0.0)
00031 , posZ(0.0)
00032 , pan(0.0)
00033 , tilt(0.0)
00034 , horizontalFov(0.0)
00035 , verticalFov(0.0)
00036 , encoding()
00037 , frameRate(0.0)
00038 , model()
00039 , synchronize(0)
00040 {
00041 }
00042
00043 VirtualCameraParameters_(const ContainerAllocator& _alloc)
00044 : approxDistance(0.0)
00045 , viewportWidth(0)
00046 , viewportHeight(0)
00047 , parentFrameId(_alloc)
00048 , posX(0.0)
00049 , posY(0.0)
00050 , posZ(0.0)
00051 , pan(0.0)
00052 , tilt(0.0)
00053 , horizontalFov(0.0)
00054 , verticalFov(0.0)
00055 , encoding(_alloc)
00056 , frameRate(0.0)
00057 , model(_alloc)
00058 , synchronize(0)
00059 {
00060 }
00061
00062 typedef double _approxDistance_type;
00063 double approxDistance;
00064
00065 typedef int32_t _viewportWidth_type;
00066 int32_t viewportWidth;
00067
00068 typedef int32_t _viewportHeight_type;
00069 int32_t viewportHeight;
00070
00071 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _parentFrameId_type;
00072 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > parentFrameId;
00073
00074 typedef double _posX_type;
00075 double posX;
00076
00077 typedef double _posY_type;
00078 double posY;
00079
00080 typedef double _posZ_type;
00081 double posZ;
00082
00083 typedef double _pan_type;
00084 double pan;
00085
00086 typedef double _tilt_type;
00087 double tilt;
00088
00089 typedef double _horizontalFov_type;
00090 double horizontalFov;
00091
00092 typedef double _verticalFov_type;
00093 double verticalFov;
00094
00095 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _encoding_type;
00096 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > encoding;
00097
00098 typedef double _frameRate_type;
00099 double frameRate;
00100
00101 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _model_type;
00102 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > model;
00103
00104 typedef int32_t _synchronize_type;
00105 int32_t synchronize;
00106
00107
00108 typedef boost::shared_ptr< ::virtual_camera::VirtualCameraParameters_<ContainerAllocator> > Ptr;
00109 typedef boost::shared_ptr< ::virtual_camera::VirtualCameraParameters_<ContainerAllocator> const> ConstPtr;
00110 boost::shared_ptr<std::map<std::string, std::string> > __connection_header;
00111 };
00112 typedef ::virtual_camera::VirtualCameraParameters_<std::allocator<void> > VirtualCameraParameters;
00113
00114 typedef boost::shared_ptr< ::virtual_camera::VirtualCameraParameters> VirtualCameraParametersPtr;
00115 typedef boost::shared_ptr< ::virtual_camera::VirtualCameraParameters const> VirtualCameraParametersConstPtr;
00116
00117
00118 template<typename ContainerAllocator>
00119 std::ostream& operator<<(std::ostream& s, const ::virtual_camera::VirtualCameraParameters_<ContainerAllocator> & v)
00120 {
00121 ros::message_operations::Printer< ::virtual_camera::VirtualCameraParameters_<ContainerAllocator> >::stream(s, "", v);
00122 return s;}
00123
00124 }
00125
00126 namespace ros
00127 {
00128 namespace message_traits
00129 {
00130 template<class ContainerAllocator> struct IsMessage< ::virtual_camera::VirtualCameraParameters_<ContainerAllocator> > : public TrueType {};
00131 template<class ContainerAllocator> struct IsMessage< ::virtual_camera::VirtualCameraParameters_<ContainerAllocator> const> : public TrueType {};
00132 template<class ContainerAllocator>
00133 struct MD5Sum< ::virtual_camera::VirtualCameraParameters_<ContainerAllocator> > {
00134 static const char* value()
00135 {
00136 return "f3a12fac277c51870b3fd0aa037b2622";
00137 }
00138
00139 static const char* value(const ::virtual_camera::VirtualCameraParameters_<ContainerAllocator> &) { return value(); }
00140 static const uint64_t static_value1 = 0xf3a12fac277c5187ULL;
00141 static const uint64_t static_value2 = 0x0b3fd0aa037b2622ULL;
00142 };
00143
00144 template<class ContainerAllocator>
00145 struct DataType< ::virtual_camera::VirtualCameraParameters_<ContainerAllocator> > {
00146 static const char* value()
00147 {
00148 return "virtual_camera/VirtualCameraParameters";
00149 }
00150
00151 static const char* value(const ::virtual_camera::VirtualCameraParameters_<ContainerAllocator> &) { return value(); }
00152 };
00153
00154 template<class ContainerAllocator>
00155 struct Definition< ::virtual_camera::VirtualCameraParameters_<ContainerAllocator> > {
00156 static const char* value()
00157 {
00158 return "#Distance of lookat points of this camera\n\
00159 float64 approxDistance\n\
00160 # Viewport width, in pixels.\n\
00161 int32 viewportWidth\n\
00162 # Viewport height, in pixels.\n\
00163 int32 viewportHeight\n\
00164 #Frame_ID of the frame the camera frame is positioned in\n\
00165 string parentFrameId\n\
00166 #X position of the camera in the parent frame\n\
00167 float64 posX\n\
00168 #Y position of the camera in the parent frame\n\
00169 float64 posY\n\
00170 #Z position of the camera in the parent frame\n\
00171 float64 posZ\n\
00172 # Horizontal pan (i.e. azimuth) of the camera, in degrees.\n\
00173 # Angular displacement measured from the positive x axis of the /omnicam frame.\n\
00174 # Positive pan corresponds to looking left.\n\
00175 float64 pan\n\
00176 # Vertical tilt (i.e. elevation) of the camera, in degrees.\n\
00177 # Angular displacement measured from the x-y plane of the /omnicam frame.\n\
00178 # Positive tilt corresponds to looking up.\n\
00179 float64 tilt\n\
00180 # Field of view in horizontal direction, fills the viewport in horizontal direction, in degrees.\n\
00181 float64 horizontalFov\n\
00182 # Field of view in vertical direction, fills the viewport in vertical direction, in degrees.\n\
00183 float64 verticalFov\n\
00184 #encoding of the cameras image. Currently supported \n\
00185 #encodings are(case sensitive): bgr8\n\
00186 string encoding\n\
00187 # Camera frame rate\n\
00188 float64 frameRate\n\
00189 #Camera model. Possible values: pinhole, cylindric, spherical.\n\
00190 #If the value is invalid then the pinhole camera model is used.\n\
00191 string model\n\
00192 # Whether to compose images only when the source timestamps are the same.\n\
00193 #0 for not synchronizing, 1 for synchronizing\n\
00194 int32 synchronize\n\
00195 \n\
00196 \n\
00197 ";
00198 }
00199
00200 static const char* value(const ::virtual_camera::VirtualCameraParameters_<ContainerAllocator> &) { return value(); }
00201 };
00202
00203 }
00204 }
00205
00206 namespace ros
00207 {
00208 namespace serialization
00209 {
00210
00211 template<class ContainerAllocator> struct Serializer< ::virtual_camera::VirtualCameraParameters_<ContainerAllocator> >
00212 {
00213 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00214 {
00215 stream.next(m.approxDistance);
00216 stream.next(m.viewportWidth);
00217 stream.next(m.viewportHeight);
00218 stream.next(m.parentFrameId);
00219 stream.next(m.posX);
00220 stream.next(m.posY);
00221 stream.next(m.posZ);
00222 stream.next(m.pan);
00223 stream.next(m.tilt);
00224 stream.next(m.horizontalFov);
00225 stream.next(m.verticalFov);
00226 stream.next(m.encoding);
00227 stream.next(m.frameRate);
00228 stream.next(m.model);
00229 stream.next(m.synchronize);
00230 }
00231
00232 ROS_DECLARE_ALLINONE_SERIALIZER;
00233 };
00234 }
00235 }
00236
00237 namespace ros
00238 {
00239 namespace message_operations
00240 {
00241
00242 template<class ContainerAllocator>
00243 struct Printer< ::virtual_camera::VirtualCameraParameters_<ContainerAllocator> >
00244 {
00245 template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::virtual_camera::VirtualCameraParameters_<ContainerAllocator> & v)
00246 {
00247 s << indent << "approxDistance: ";
00248 Printer<double>::stream(s, indent + " ", v.approxDistance);
00249 s << indent << "viewportWidth: ";
00250 Printer<int32_t>::stream(s, indent + " ", v.viewportWidth);
00251 s << indent << "viewportHeight: ";
00252 Printer<int32_t>::stream(s, indent + " ", v.viewportHeight);
00253 s << indent << "parentFrameId: ";
00254 Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.parentFrameId);
00255 s << indent << "posX: ";
00256 Printer<double>::stream(s, indent + " ", v.posX);
00257 s << indent << "posY: ";
00258 Printer<double>::stream(s, indent + " ", v.posY);
00259 s << indent << "posZ: ";
00260 Printer<double>::stream(s, indent + " ", v.posZ);
00261 s << indent << "pan: ";
00262 Printer<double>::stream(s, indent + " ", v.pan);
00263 s << indent << "tilt: ";
00264 Printer<double>::stream(s, indent + " ", v.tilt);
00265 s << indent << "horizontalFov: ";
00266 Printer<double>::stream(s, indent + " ", v.horizontalFov);
00267 s << indent << "verticalFov: ";
00268 Printer<double>::stream(s, indent + " ", v.verticalFov);
00269 s << indent << "encoding: ";
00270 Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.encoding);
00271 s << indent << "frameRate: ";
00272 Printer<double>::stream(s, indent + " ", v.frameRate);
00273 s << indent << "model: ";
00274 Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.model);
00275 s << indent << "synchronize: ";
00276 Printer<int32_t>::stream(s, indent + " ", v.synchronize);
00277 }
00278 };
00279
00280
00281 }
00282 }
00283
00284 #endif // VIRTUAL_CAMERA_MESSAGE_VIRTUALCAMERAPARAMETERS_H
00285