v01

thirdparty/ros/include/sensor_msgs/BatteryState.h

@@ -0,0 +1,537 @@
+// Generated by gencpp from file sensor_msgs/BatteryState.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_BATTERYSTATE_H
+#define SENSOR_MSGS_MESSAGE_BATTERYSTATE_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <std_msgs/Header.h>
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct BatteryState_
+{
+  typedef BatteryState_<ContainerAllocator> Type;
+
+  BatteryState_()
+    : header()
+    , voltage(0.0)
+    , temperature(0.0)
+    , current(0.0)
+    , charge(0.0)
+    , capacity(0.0)
+    , design_capacity(0.0)
+    , percentage(0.0)
+    , power_supply_status(0)
+    , power_supply_health(0)
+    , power_supply_technology(0)
+    , present(false)
+    , cell_voltage()
+    , cell_temperature()
+    , location()
+    , serial_number()  {
+    }
+  BatteryState_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , voltage(0.0)
+    , temperature(0.0)
+    , current(0.0)
+    , charge(0.0)
+    , capacity(0.0)
+    , design_capacity(0.0)
+    , percentage(0.0)
+    , power_supply_status(0)
+    , power_supply_health(0)
+    , power_supply_technology(0)
+    , present(false)
+    , cell_voltage(_alloc)
+    , cell_temperature(_alloc)
+    , location(_alloc)
+    , serial_number(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
+  _header_type header;
+
+   typedef float _voltage_type;
+  _voltage_type voltage;
+
+   typedef float _temperature_type;
+  _temperature_type temperature;
+
+   typedef float _current_type;
+  _current_type current;
+
+   typedef float _charge_type;
+  _charge_type charge;
+
+   typedef float _capacity_type;
+  _capacity_type capacity;
+
+   typedef float _design_capacity_type;
+  _design_capacity_type design_capacity;
+
+   typedef float _percentage_type;
+  _percentage_type percentage;
+
+   typedef uint8_t _power_supply_status_type;
+  _power_supply_status_type power_supply_status;
+
+   typedef uint8_t _power_supply_health_type;
+  _power_supply_health_type power_supply_health;
+
+   typedef uint8_t _power_supply_technology_type;
+  _power_supply_technology_type power_supply_technology;
+
+   typedef uint8_t _present_type;
+  _present_type present;
+
+   typedef std::vector<float, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<float>> _cell_voltage_type;
+  _cell_voltage_type cell_voltage;
+
+   typedef std::vector<float, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<float>> _cell_temperature_type;
+  _cell_temperature_type cell_temperature;
+
+   typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _location_type;
+  _location_type location;
+
+   typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _serial_number_type;
+  _serial_number_type serial_number;
+
+
+
+// reducing the odds to have name collisions with Windows.h 
+#if defined(_WIN32) && defined(POWER_SUPPLY_STATUS_UNKNOWN)
+  #undef POWER_SUPPLY_STATUS_UNKNOWN
+#endif
+#if defined(_WIN32) && defined(POWER_SUPPLY_STATUS_CHARGING)
+  #undef POWER_SUPPLY_STATUS_CHARGING
+#endif
+#if defined(_WIN32) && defined(POWER_SUPPLY_STATUS_DISCHARGING)
+  #undef POWER_SUPPLY_STATUS_DISCHARGING
+#endif
+#if defined(_WIN32) && defined(POWER_SUPPLY_STATUS_NOT_CHARGING)
+  #undef POWER_SUPPLY_STATUS_NOT_CHARGING
+#endif
+#if defined(_WIN32) && defined(POWER_SUPPLY_STATUS_FULL)
+  #undef POWER_SUPPLY_STATUS_FULL
+#endif
+#if defined(_WIN32) && defined(POWER_SUPPLY_HEALTH_UNKNOWN)
+  #undef POWER_SUPPLY_HEALTH_UNKNOWN
+#endif
+#if defined(_WIN32) && defined(POWER_SUPPLY_HEALTH_GOOD)
+  #undef POWER_SUPPLY_HEALTH_GOOD
+#endif
+#if defined(_WIN32) && defined(POWER_SUPPLY_HEALTH_OVERHEAT)
+  #undef POWER_SUPPLY_HEALTH_OVERHEAT
+#endif
+#if defined(_WIN32) && defined(POWER_SUPPLY_HEALTH_DEAD)
+  #undef POWER_SUPPLY_HEALTH_DEAD
+#endif
+#if defined(_WIN32) && defined(POWER_SUPPLY_HEALTH_OVERVOLTAGE)
+  #undef POWER_SUPPLY_HEALTH_OVERVOLTAGE
+#endif
+#if defined(_WIN32) && defined(POWER_SUPPLY_HEALTH_UNSPEC_FAILURE)
+  #undef POWER_SUPPLY_HEALTH_UNSPEC_FAILURE
+#endif
+#if defined(_WIN32) && defined(POWER_SUPPLY_HEALTH_COLD)
+  #undef POWER_SUPPLY_HEALTH_COLD
+#endif
+#if defined(_WIN32) && defined(POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE)
+  #undef POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE
+#endif
+#if defined(_WIN32) && defined(POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE)
+  #undef POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE
+#endif
+#if defined(_WIN32) && defined(POWER_SUPPLY_TECHNOLOGY_UNKNOWN)
+  #undef POWER_SUPPLY_TECHNOLOGY_UNKNOWN
+#endif
+#if defined(_WIN32) && defined(POWER_SUPPLY_TECHNOLOGY_NIMH)
+  #undef POWER_SUPPLY_TECHNOLOGY_NIMH
+#endif
+#if defined(_WIN32) && defined(POWER_SUPPLY_TECHNOLOGY_LION)
+  #undef POWER_SUPPLY_TECHNOLOGY_LION
+#endif
+#if defined(_WIN32) && defined(POWER_SUPPLY_TECHNOLOGY_LIPO)
+  #undef POWER_SUPPLY_TECHNOLOGY_LIPO
+#endif
+#if defined(_WIN32) && defined(POWER_SUPPLY_TECHNOLOGY_LIFE)
+  #undef POWER_SUPPLY_TECHNOLOGY_LIFE
+#endif
+#if defined(_WIN32) && defined(POWER_SUPPLY_TECHNOLOGY_NICD)
+  #undef POWER_SUPPLY_TECHNOLOGY_NICD
+#endif
+#if defined(_WIN32) && defined(POWER_SUPPLY_TECHNOLOGY_LIMN)
+  #undef POWER_SUPPLY_TECHNOLOGY_LIMN
+#endif
+
+  enum {
+    POWER_SUPPLY_STATUS_UNKNOWN = 0u,
+    POWER_SUPPLY_STATUS_CHARGING = 1u,
+    POWER_SUPPLY_STATUS_DISCHARGING = 2u,
+    POWER_SUPPLY_STATUS_NOT_CHARGING = 3u,
+    POWER_SUPPLY_STATUS_FULL = 4u,
+    POWER_SUPPLY_HEALTH_UNKNOWN = 0u,
+    POWER_SUPPLY_HEALTH_GOOD = 1u,
+    POWER_SUPPLY_HEALTH_OVERHEAT = 2u,
+    POWER_SUPPLY_HEALTH_DEAD = 3u,
+    POWER_SUPPLY_HEALTH_OVERVOLTAGE = 4u,
+    POWER_SUPPLY_HEALTH_UNSPEC_FAILURE = 5u,
+    POWER_SUPPLY_HEALTH_COLD = 6u,
+    POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE = 7u,
+    POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE = 8u,
+    POWER_SUPPLY_TECHNOLOGY_UNKNOWN = 0u,
+    POWER_SUPPLY_TECHNOLOGY_NIMH = 1u,
+    POWER_SUPPLY_TECHNOLOGY_LION = 2u,
+    POWER_SUPPLY_TECHNOLOGY_LIPO = 3u,
+    POWER_SUPPLY_TECHNOLOGY_LIFE = 4u,
+    POWER_SUPPLY_TECHNOLOGY_NICD = 5u,
+    POWER_SUPPLY_TECHNOLOGY_LIMN = 6u,
+  };
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::BatteryState_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::BatteryState_<ContainerAllocator> const> ConstPtr;
+
+}; // struct BatteryState_
+
+typedef ::sensor_msgs::BatteryState_<std::allocator<void> > BatteryState;
+
+typedef boost::shared_ptr< ::sensor_msgs::BatteryState > BatteryStatePtr;
+typedef boost::shared_ptr< ::sensor_msgs::BatteryState const> BatteryStateConstPtr;
+
+// constants requiring out of line definition
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::BatteryState_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::BatteryState_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::BatteryState_<ContainerAllocator1> & lhs, const ::sensor_msgs::BatteryState_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.voltage == rhs.voltage &&
+    lhs.temperature == rhs.temperature &&
+    lhs.current == rhs.current &&
+    lhs.charge == rhs.charge &&
+    lhs.capacity == rhs.capacity &&
+    lhs.design_capacity == rhs.design_capacity &&
+    lhs.percentage == rhs.percentage &&
+    lhs.power_supply_status == rhs.power_supply_status &&
+    lhs.power_supply_health == rhs.power_supply_health &&
+    lhs.power_supply_technology == rhs.power_supply_technology &&
+    lhs.present == rhs.present &&
+    lhs.cell_voltage == rhs.cell_voltage &&
+    lhs.cell_temperature == rhs.cell_temperature &&
+    lhs.location == rhs.location &&
+    lhs.serial_number == rhs.serial_number;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::BatteryState_<ContainerAllocator1> & lhs, const ::sensor_msgs::BatteryState_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::BatteryState_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::BatteryState_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::BatteryState_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::BatteryState_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::BatteryState_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::BatteryState_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::BatteryState_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "4ddae7f048e32fda22cac764685e3974";
+  }
+
+  static const char* value(const ::sensor_msgs::BatteryState_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x4ddae7f048e32fdaULL;
+  static const uint64_t static_value2 = 0x22cac764685e3974ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::BatteryState_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/BatteryState";
+  }
+
+  static const char* value(const ::sensor_msgs::BatteryState_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::BatteryState_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "\n"
+"# Constants are chosen to match the enums in the linux kernel\n"
+"# defined in include/linux/power_supply.h as of version 3.7\n"
+"# The one difference is for style reasons the constants are\n"
+"# all uppercase not mixed case.\n"
+"\n"
+"# Power supply status constants\n"
+"uint8 POWER_SUPPLY_STATUS_UNKNOWN = 0\n"
+"uint8 POWER_SUPPLY_STATUS_CHARGING = 1\n"
+"uint8 POWER_SUPPLY_STATUS_DISCHARGING = 2\n"
+"uint8 POWER_SUPPLY_STATUS_NOT_CHARGING = 3\n"
+"uint8 POWER_SUPPLY_STATUS_FULL = 4\n"
+"\n"
+"# Power supply health constants\n"
+"uint8 POWER_SUPPLY_HEALTH_UNKNOWN = 0\n"
+"uint8 POWER_SUPPLY_HEALTH_GOOD = 1\n"
+"uint8 POWER_SUPPLY_HEALTH_OVERHEAT = 2\n"
+"uint8 POWER_SUPPLY_HEALTH_DEAD = 3\n"
+"uint8 POWER_SUPPLY_HEALTH_OVERVOLTAGE = 4\n"
+"uint8 POWER_SUPPLY_HEALTH_UNSPEC_FAILURE = 5\n"
+"uint8 POWER_SUPPLY_HEALTH_COLD = 6\n"
+"uint8 POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE = 7\n"
+"uint8 POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE = 8\n"
+"\n"
+"# Power supply technology (chemistry) constants\n"
+"uint8 POWER_SUPPLY_TECHNOLOGY_UNKNOWN = 0\n"
+"uint8 POWER_SUPPLY_TECHNOLOGY_NIMH = 1\n"
+"uint8 POWER_SUPPLY_TECHNOLOGY_LION = 2\n"
+"uint8 POWER_SUPPLY_TECHNOLOGY_LIPO = 3\n"
+"uint8 POWER_SUPPLY_TECHNOLOGY_LIFE = 4\n"
+"uint8 POWER_SUPPLY_TECHNOLOGY_NICD = 5\n"
+"uint8 POWER_SUPPLY_TECHNOLOGY_LIMN = 6\n"
+"\n"
+"Header  header\n"
+"float32 voltage          # Voltage in Volts (Mandatory)\n"
+"float32 temperature      # Temperature in Degrees Celsius (If unmeasured NaN)\n"
+"float32 current          # Negative when discharging (A)  (If unmeasured NaN)\n"
+"float32 charge           # Current charge in Ah  (If unmeasured NaN)\n"
+"float32 capacity         # Capacity in Ah (last full capacity)  (If unmeasured NaN)\n"
+"float32 design_capacity  # Capacity in Ah (design capacity)  (If unmeasured NaN)\n"
+"float32 percentage       # Charge percentage on 0 to 1 range  (If unmeasured NaN)\n"
+"uint8   power_supply_status     # The charging status as reported. Values defined above\n"
+"uint8   power_supply_health     # The battery health metric. Values defined above\n"
+"uint8   power_supply_technology # The battery chemistry. Values defined above\n"
+"bool    present          # True if the battery is present\n"
+"\n"
+"float32[] cell_voltage   # An array of individual cell voltages for each cell in the pack\n"
+"                         # If individual voltages unknown but number of cells known set each to NaN\n"
+"float32[] cell_temperature  # An array of individual cell temperatures for each cell in the pack\n"
+"                            # If individual temperatures unknown but number of cells known set each to NaN\n"
+"string location          # The location into which the battery is inserted. (slot number or plug)\n"
+"string serial_number     # The best approximation of the battery serial number\n"
+"\n"
+"================================================================================\n"
+"MSG: std_msgs/Header\n"
+"# Standard metadata for higher-level stamped data types.\n"
+"# This is generally used to communicate timestamped data \n"
+"# in a particular coordinate frame.\n"
+"# \n"
+"# sequence ID: consecutively increasing ID \n"
+"uint32 seq\n"
+"#Two-integer timestamp that is expressed as:\n"
+"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
+"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
+"# time-handling sugar is provided by the client library\n"
+"time stamp\n"
+"#Frame this data is associated with\n"
+"string frame_id\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::BatteryState_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::BatteryState_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.header);
+      stream.next(m.voltage);
+      stream.next(m.temperature);
+      stream.next(m.current);
+      stream.next(m.charge);
+      stream.next(m.capacity);
+      stream.next(m.design_capacity);
+      stream.next(m.percentage);
+      stream.next(m.power_supply_status);
+      stream.next(m.power_supply_health);
+      stream.next(m.power_supply_technology);
+      stream.next(m.present);
+      stream.next(m.cell_voltage);
+      stream.next(m.cell_temperature);
+      stream.next(m.location);
+      stream.next(m.serial_number);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct BatteryState_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::BatteryState_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::BatteryState_<ContainerAllocator>& v)
+  {
+    s << indent << "header: ";
+    s << std::endl;
+    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
+    s << indent << "voltage: ";
+    Printer<float>::stream(s, indent + "  ", v.voltage);
+    s << indent << "temperature: ";
+    Printer<float>::stream(s, indent + "  ", v.temperature);
+    s << indent << "current: ";
+    Printer<float>::stream(s, indent + "  ", v.current);
+    s << indent << "charge: ";
+    Printer<float>::stream(s, indent + "  ", v.charge);
+    s << indent << "capacity: ";
+    Printer<float>::stream(s, indent + "  ", v.capacity);
+    s << indent << "design_capacity: ";
+    Printer<float>::stream(s, indent + "  ", v.design_capacity);
+    s << indent << "percentage: ";
+    Printer<float>::stream(s, indent + "  ", v.percentage);
+    s << indent << "power_supply_status: ";
+    Printer<uint8_t>::stream(s, indent + "  ", v.power_supply_status);
+    s << indent << "power_supply_health: ";
+    Printer<uint8_t>::stream(s, indent + "  ", v.power_supply_health);
+    s << indent << "power_supply_technology: ";
+    Printer<uint8_t>::stream(s, indent + "  ", v.power_supply_technology);
+    s << indent << "present: ";
+    Printer<uint8_t>::stream(s, indent + "  ", v.present);
+    s << indent << "cell_voltage[]" << std::endl;
+    for (size_t i = 0; i < v.cell_voltage.size(); ++i)
+    {
+      s << indent << "  cell_voltage[" << i << "]: ";
+      Printer<float>::stream(s, indent + "  ", v.cell_voltage[i]);
+    }
+    s << indent << "cell_temperature[]" << std::endl;
+    for (size_t i = 0; i < v.cell_temperature.size(); ++i)
+    {
+      s << indent << "  cell_temperature[" << i << "]: ";
+      Printer<float>::stream(s, indent + "  ", v.cell_temperature[i]);
+    }
+    s << indent << "location: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>::stream(s, indent + "  ", v.location);
+    s << indent << "serial_number: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>::stream(s, indent + "  ", v.serial_number);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_BATTERYSTATE_H

thirdparty/ros/include/sensor_msgs/CameraInfo.h

@@ -0,0 +1,483 @@
+// Generated by gencpp from file sensor_msgs/CameraInfo.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_CAMERAINFO_H
+#define SENSOR_MSGS_MESSAGE_CAMERAINFO_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <std_msgs/Header.h>
+#include <sensor_msgs/RegionOfInterest.h>
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct CameraInfo_
+{
+  typedef CameraInfo_<ContainerAllocator> Type;
+
+  CameraInfo_()
+    : header()
+    , height(0)
+    , width(0)
+    , distortion_model()
+    , D()
+    , K()
+    , R()
+    , P()
+    , binning_x(0)
+    , binning_y(0)
+    , roi()  {
+      K.assign(0.0);
+
+      R.assign(0.0);
+
+      P.assign(0.0);
+  }
+  CameraInfo_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , height(0)
+    , width(0)
+    , distortion_model(_alloc)
+    , D(_alloc)
+    , K()
+    , R()
+    , P()
+    , binning_x(0)
+    , binning_y(0)
+    , roi(_alloc)  {
+  (void)_alloc;
+      K.assign(0.0);
+
+      R.assign(0.0);
+
+      P.assign(0.0);
+  }
+
+
+
+   typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
+  _header_type header;
+
+   typedef uint32_t _height_type;
+  _height_type height;
+
+   typedef uint32_t _width_type;
+  _width_type width;
+
+   typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _distortion_model_type;
+  _distortion_model_type distortion_model;
+
+   typedef std::vector<double, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<double>> _D_type;
+  _D_type D;
+
+   typedef boost::array<double, 9>  _K_type;
+  _K_type K;
+
+   typedef boost::array<double, 9>  _R_type;
+  _R_type R;
+
+   typedef boost::array<double, 12>  _P_type;
+  _P_type P;
+
+   typedef uint32_t _binning_x_type;
+  _binning_x_type binning_x;
+
+   typedef uint32_t _binning_y_type;
+  _binning_y_type binning_y;
+
+   typedef  ::sensor_msgs::RegionOfInterest_<ContainerAllocator>  _roi_type;
+  _roi_type roi;
+
+
+
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::CameraInfo_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::CameraInfo_<ContainerAllocator> const> ConstPtr;
+
+}; // struct CameraInfo_
+
+typedef ::sensor_msgs::CameraInfo_<std::allocator<void> > CameraInfo;
+
+typedef boost::shared_ptr< ::sensor_msgs::CameraInfo > CameraInfoPtr;
+typedef boost::shared_ptr< ::sensor_msgs::CameraInfo const> CameraInfoConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::CameraInfo_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::CameraInfo_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::CameraInfo_<ContainerAllocator1> & lhs, const ::sensor_msgs::CameraInfo_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.height == rhs.height &&
+    lhs.width == rhs.width &&
+    lhs.distortion_model == rhs.distortion_model &&
+    lhs.D == rhs.D &&
+    lhs.K == rhs.K &&
+    lhs.R == rhs.R &&
+    lhs.P == rhs.P &&
+    lhs.binning_x == rhs.binning_x &&
+    lhs.binning_y == rhs.binning_y &&
+    lhs.roi == rhs.roi;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::CameraInfo_<ContainerAllocator1> & lhs, const ::sensor_msgs::CameraInfo_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::CameraInfo_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::CameraInfo_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::CameraInfo_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::CameraInfo_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::CameraInfo_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::CameraInfo_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::CameraInfo_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "c9a58c1b0b154e0e6da7578cb991d214";
+  }
+
+  static const char* value(const ::sensor_msgs::CameraInfo_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0xc9a58c1b0b154e0eULL;
+  static const uint64_t static_value2 = 0x6da7578cb991d214ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::CameraInfo_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/CameraInfo";
+  }
+
+  static const char* value(const ::sensor_msgs::CameraInfo_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::CameraInfo_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# This message defines meta information for a camera. It should be in a\n"
+"# camera namespace on topic \"camera_info\" and accompanied by up to five\n"
+"# image topics named:\n"
+"#\n"
+"#   image_raw - raw data from the camera driver, possibly Bayer encoded\n"
+"#   image            - monochrome, distorted\n"
+"#   image_color      - color, distorted\n"
+"#   image_rect       - monochrome, rectified\n"
+"#   image_rect_color - color, rectified\n"
+"#\n"
+"# The image_pipeline contains packages (image_proc, stereo_image_proc)\n"
+"# for producing the four processed image topics from image_raw and\n"
+"# camera_info. The meaning of the camera parameters are described in\n"
+"# detail at http://www.ros.org/wiki/image_pipeline/CameraInfo.\n"
+"#\n"
+"# The image_geometry package provides a user-friendly interface to\n"
+"# common operations using this meta information. If you want to, e.g.,\n"
+"# project a 3d point into image coordinates, we strongly recommend\n"
+"# using image_geometry.\n"
+"#\n"
+"# If the camera is uncalibrated, the matrices D, K, R, P should be left\n"
+"# zeroed out. In particular, clients may assume that K[0] == 0.0\n"
+"# indicates an uncalibrated camera.\n"
+"\n"
+"#######################################################################\n"
+"#                     Image acquisition info                          #\n"
+"#######################################################################\n"
+"\n"
+"# Time of image acquisition, camera coordinate frame ID\n"
+"Header header    # Header timestamp should be acquisition time of image\n"
+"                 # Header frame_id should be optical frame of camera\n"
+"                 # origin of frame should be optical center of camera\n"
+"                 # +x should point to the right in the image\n"
+"                 # +y should point down in the image\n"
+"                 # +z should point into the plane of the image\n"
+"\n"
+"\n"
+"#######################################################################\n"
+"#                      Calibration Parameters                         #\n"
+"#######################################################################\n"
+"# These are fixed during camera calibration. Their values will be the #\n"
+"# same in all messages until the camera is recalibrated. Note that    #\n"
+"# self-calibrating systems may \"recalibrate\" frequently.              #\n"
+"#                                                                     #\n"
+"# The internal parameters can be used to warp a raw (distorted) image #\n"
+"# to:                                                                 #\n"
+"#   1. An undistorted image (requires D and K)                        #\n"
+"#   2. A rectified image (requires D, K, R)                           #\n"
+"# The projection matrix P projects 3D points into the rectified image.#\n"
+"#######################################################################\n"
+"\n"
+"# The image dimensions with which the camera was calibrated. Normally\n"
+"# this will be the full camera resolution in pixels.\n"
+"uint32 height\n"
+"uint32 width\n"
+"\n"
+"# The distortion model used. Supported models are listed in\n"
+"# sensor_msgs/distortion_models.h. For most cameras, \"plumb_bob\" - a\n"
+"# simple model of radial and tangential distortion - is sufficient.\n"
+"string distortion_model\n"
+"\n"
+"# The distortion parameters, size depending on the distortion model.\n"
+"# For \"plumb_bob\", the 5 parameters are: (k1, k2, t1, t2, k3).\n"
+"float64[] D\n"
+"\n"
+"# Intrinsic camera matrix for the raw (distorted) images.\n"
+"#     [fx  0 cx]\n"
+"# K = [ 0 fy cy]\n"
+"#     [ 0  0  1]\n"
+"# Projects 3D points in the camera coordinate frame to 2D pixel\n"
+"# coordinates using the focal lengths (fx, fy) and principal point\n"
+"# (cx, cy).\n"
+"float64[9]  K # 3x3 row-major matrix\n"
+"\n"
+"# Rectification matrix (stereo cameras only)\n"
+"# A rotation matrix aligning the camera coordinate system to the ideal\n"
+"# stereo image plane so that epipolar lines in both stereo images are\n"
+"# parallel.\n"
+"float64[9]  R # 3x3 row-major matrix\n"
+"\n"
+"# Projection/camera matrix\n"
+"#     [fx'  0  cx' Tx]\n"
+"# P = [ 0  fy' cy' Ty]\n"
+"#     [ 0   0   1   0]\n"
+"# By convention, this matrix specifies the intrinsic (camera) matrix\n"
+"#  of the processed (rectified) image. That is, the left 3x3 portion\n"
+"#  is the normal camera intrinsic matrix for the rectified image.\n"
+"# It projects 3D points in the camera coordinate frame to 2D pixel\n"
+"#  coordinates using the focal lengths (fx', fy') and principal point\n"
+"#  (cx', cy') - these may differ from the values in K.\n"
+"# For monocular cameras, Tx = Ty = 0. Normally, monocular cameras will\n"
+"#  also have R = the identity and P[1:3,1:3] = K.\n"
+"# For a stereo pair, the fourth column [Tx Ty 0]' is related to the\n"
+"#  position of the optical center of the second camera in the first\n"
+"#  camera's frame. We assume Tz = 0 so both cameras are in the same\n"
+"#  stereo image plane. The first camera always has Tx = Ty = 0. For\n"
+"#  the right (second) camera of a horizontal stereo pair, Ty = 0 and\n"
+"#  Tx = -fx' * B, where B is the baseline between the cameras.\n"
+"# Given a 3D point [X Y Z]', the projection (x, y) of the point onto\n"
+"#  the rectified image is given by:\n"
+"#  [u v w]' = P * [X Y Z 1]'\n"
+"#         x = u / w\n"
+"#         y = v / w\n"
+"#  This holds for both images of a stereo pair.\n"
+"float64[12] P # 3x4 row-major matrix\n"
+"\n"
+"\n"
+"#######################################################################\n"
+"#                      Operational Parameters                         #\n"
+"#######################################################################\n"
+"# These define the image region actually captured by the camera       #\n"
+"# driver. Although they affect the geometry of the output image, they #\n"
+"# may be changed freely without recalibrating the camera.             #\n"
+"#######################################################################\n"
+"\n"
+"# Binning refers here to any camera setting which combines rectangular\n"
+"#  neighborhoods of pixels into larger \"super-pixels.\" It reduces the\n"
+"#  resolution of the output image to\n"
+"#  (width / binning_x) x (height / binning_y).\n"
+"# The default values binning_x = binning_y = 0 is considered the same\n"
+"#  as binning_x = binning_y = 1 (no subsampling).\n"
+"uint32 binning_x\n"
+"uint32 binning_y\n"
+"\n"
+"# Region of interest (subwindow of full camera resolution), given in\n"
+"#  full resolution (unbinned) image coordinates. A particular ROI\n"
+"#  always denotes the same window of pixels on the camera sensor,\n"
+"#  regardless of binning settings.\n"
+"# The default setting of roi (all values 0) is considered the same as\n"
+"#  full resolution (roi.width = width, roi.height = height).\n"
+"RegionOfInterest roi\n"
+"\n"
+"================================================================================\n"
+"MSG: std_msgs/Header\n"
+"# Standard metadata for higher-level stamped data types.\n"
+"# This is generally used to communicate timestamped data \n"
+"# in a particular coordinate frame.\n"
+"# \n"
+"# sequence ID: consecutively increasing ID \n"
+"uint32 seq\n"
+"#Two-integer timestamp that is expressed as:\n"
+"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
+"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
+"# time-handling sugar is provided by the client library\n"
+"time stamp\n"
+"#Frame this data is associated with\n"
+"string frame_id\n"
+"\n"
+"================================================================================\n"
+"MSG: sensor_msgs/RegionOfInterest\n"
+"# This message is used to specify a region of interest within an image.\n"
+"#\n"
+"# When used to specify the ROI setting of the camera when the image was\n"
+"# taken, the height and width fields should either match the height and\n"
+"# width fields for the associated image; or height = width = 0\n"
+"# indicates that the full resolution image was captured.\n"
+"\n"
+"uint32 x_offset  # Leftmost pixel of the ROI\n"
+"                 # (0 if the ROI includes the left edge of the image)\n"
+"uint32 y_offset  # Topmost pixel of the ROI\n"
+"                 # (0 if the ROI includes the top edge of the image)\n"
+"uint32 height    # Height of ROI\n"
+"uint32 width     # Width of ROI\n"
+"\n"
+"# True if a distinct rectified ROI should be calculated from the \"raw\"\n"
+"# ROI in this message. Typically this should be False if the full image\n"
+"# is captured (ROI not used), and True if a subwindow is captured (ROI\n"
+"# used).\n"
+"bool do_rectify\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::CameraInfo_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::CameraInfo_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.header);
+      stream.next(m.height);
+      stream.next(m.width);
+      stream.next(m.distortion_model);
+      stream.next(m.D);
+      stream.next(m.K);
+      stream.next(m.R);
+      stream.next(m.P);
+      stream.next(m.binning_x);
+      stream.next(m.binning_y);
+      stream.next(m.roi);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct CameraInfo_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::CameraInfo_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::CameraInfo_<ContainerAllocator>& v)
+  {
+    s << indent << "header: ";
+    s << std::endl;
+    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
+    s << indent << "height: ";
+    Printer<uint32_t>::stream(s, indent + "  ", v.height);
+    s << indent << "width: ";
+    Printer<uint32_t>::stream(s, indent + "  ", v.width);
+    s << indent << "distortion_model: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>::stream(s, indent + "  ", v.distortion_model);
+    s << indent << "D[]" << std::endl;
+    for (size_t i = 0; i < v.D.size(); ++i)
+    {
+      s << indent << "  D[" << i << "]: ";
+      Printer<double>::stream(s, indent + "  ", v.D[i]);
+    }
+    s << indent << "K[]" << std::endl;
+    for (size_t i = 0; i < v.K.size(); ++i)
+    {
+      s << indent << "  K[" << i << "]: ";
+      Printer<double>::stream(s, indent + "  ", v.K[i]);
+    }
+    s << indent << "R[]" << std::endl;
+    for (size_t i = 0; i < v.R.size(); ++i)
+    {
+      s << indent << "  R[" << i << "]: ";
+      Printer<double>::stream(s, indent + "  ", v.R[i]);
+    }
+    s << indent << "P[]" << std::endl;
+    for (size_t i = 0; i < v.P.size(); ++i)
+    {
+      s << indent << "  P[" << i << "]: ";
+      Printer<double>::stream(s, indent + "  ", v.P[i]);
+    }
+    s << indent << "binning_x: ";
+    Printer<uint32_t>::stream(s, indent + "  ", v.binning_x);
+    s << indent << "binning_y: ";
+    Printer<uint32_t>::stream(s, indent + "  ", v.binning_y);
+    s << indent << "roi: ";
+    s << std::endl;
+    Printer< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> >::stream(s, indent + "  ", v.roi);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_CAMERAINFO_H

thirdparty/ros/include/sensor_msgs/ChannelFloat32.h

@@ -0,0 +1,231 @@
+// Generated by gencpp from file sensor_msgs/ChannelFloat32.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_CHANNELFLOAT32_H
+#define SENSOR_MSGS_MESSAGE_CHANNELFLOAT32_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct ChannelFloat32_
+{
+  typedef ChannelFloat32_<ContainerAllocator> Type;
+
+  ChannelFloat32_()
+    : name()
+    , values()  {
+    }
+  ChannelFloat32_(const ContainerAllocator& _alloc)
+    : name(_alloc)
+    , values(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _name_type;
+  _name_type name;
+
+   typedef std::vector<float, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<float>> _values_type;
+  _values_type values;
+
+
+
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> const> ConstPtr;
+
+}; // struct ChannelFloat32_
+
+typedef ::sensor_msgs::ChannelFloat32_<std::allocator<void> > ChannelFloat32;
+
+typedef boost::shared_ptr< ::sensor_msgs::ChannelFloat32 > ChannelFloat32Ptr;
+typedef boost::shared_ptr< ::sensor_msgs::ChannelFloat32 const> ChannelFloat32ConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::ChannelFloat32_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::ChannelFloat32_<ContainerAllocator1> & lhs, const ::sensor_msgs::ChannelFloat32_<ContainerAllocator2> & rhs)
+{
+  return lhs.name == rhs.name &&
+    lhs.values == rhs.values;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::ChannelFloat32_<ContainerAllocator1> & lhs, const ::sensor_msgs::ChannelFloat32_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "3d40139cdd33dfedcb71ffeeeb42ae7f";
+  }
+
+  static const char* value(const ::sensor_msgs::ChannelFloat32_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x3d40139cdd33dfedULL;
+  static const uint64_t static_value2 = 0xcb71ffeeeb42ae7fULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/ChannelFloat32";
+  }
+
+  static const char* value(const ::sensor_msgs::ChannelFloat32_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# This message is used by the PointCloud message to hold optional data\n"
+"# associated with each point in the cloud. The length of the values\n"
+"# array should be the same as the length of the points array in the\n"
+"# PointCloud, and each value should be associated with the corresponding\n"
+"# point.\n"
+"\n"
+"# Channel names in existing practice include:\n"
+"#   \"u\", \"v\" - row and column (respectively) in the left stereo image.\n"
+"#              This is opposite to usual conventions but remains for\n"
+"#              historical reasons. The newer PointCloud2 message has no\n"
+"#              such problem.\n"
+"#   \"rgb\" - For point clouds produced by color stereo cameras. uint8\n"
+"#           (R,G,B) values packed into the least significant 24 bits,\n"
+"#           in order.\n"
+"#   \"intensity\" - laser or pixel intensity.\n"
+"#   \"distance\"\n"
+"\n"
+"# The channel name should give semantics of the channel (e.g.\n"
+"# \"intensity\" instead of \"value\").\n"
+"string name\n"
+"\n"
+"# The values array should be 1-1 with the elements of the associated\n"
+"# PointCloud.\n"
+"float32[] values\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::ChannelFloat32_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.name);
+      stream.next(m.values);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct ChannelFloat32_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::ChannelFloat32_<ContainerAllocator>& v)
+  {
+    s << indent << "name: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>::stream(s, indent + "  ", v.name);
+    s << indent << "values[]" << std::endl;
+    for (size_t i = 0; i < v.values.size(); ++i)
+    {
+      s << indent << "  values[" << i << "]: ";
+      Printer<float>::stream(s, indent + "  ", v.values[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_CHANNELFLOAT32_H

thirdparty/ros/include/sensor_msgs/CompressedImage.h

@@ -0,0 +1,247 @@
+// Generated by gencpp from file sensor_msgs/CompressedImage.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_COMPRESSEDIMAGE_H
+#define SENSOR_MSGS_MESSAGE_COMPRESSEDIMAGE_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <std_msgs/Header.h>
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct CompressedImage_
+{
+  typedef CompressedImage_<ContainerAllocator> Type;
+
+  CompressedImage_()
+    : header()
+    , format()
+    , data()  {
+    }
+  CompressedImage_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , format(_alloc)
+    , data(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
+  _header_type header;
+
+   typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _format_type;
+  _format_type format;
+
+   typedef std::vector<uint8_t, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<uint8_t>> _data_type;
+  _data_type data;
+
+
+
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::CompressedImage_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::CompressedImage_<ContainerAllocator> const> ConstPtr;
+
+}; // struct CompressedImage_
+
+typedef ::sensor_msgs::CompressedImage_<std::allocator<void> > CompressedImage;
+
+typedef boost::shared_ptr< ::sensor_msgs::CompressedImage > CompressedImagePtr;
+typedef boost::shared_ptr< ::sensor_msgs::CompressedImage const> CompressedImageConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::CompressedImage_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::CompressedImage_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::CompressedImage_<ContainerAllocator1> & lhs, const ::sensor_msgs::CompressedImage_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.format == rhs.format &&
+    lhs.data == rhs.data;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::CompressedImage_<ContainerAllocator1> & lhs, const ::sensor_msgs::CompressedImage_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::CompressedImage_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::CompressedImage_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::CompressedImage_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::CompressedImage_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::CompressedImage_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::CompressedImage_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::CompressedImage_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "8f7a12909da2c9d3332d540a0977563f";
+  }
+
+  static const char* value(const ::sensor_msgs::CompressedImage_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x8f7a12909da2c9d3ULL;
+  static const uint64_t static_value2 = 0x332d540a0977563fULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::CompressedImage_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/CompressedImage";
+  }
+
+  static const char* value(const ::sensor_msgs::CompressedImage_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::CompressedImage_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# This message contains a compressed image\n"
+"\n"
+"Header header        # Header timestamp should be acquisition time of image\n"
+"                     # Header frame_id should be optical frame of camera\n"
+"                     # origin of frame should be optical center of camera\n"
+"                     # +x should point to the right in the image\n"
+"                     # +y should point down in the image\n"
+"                     # +z should point into to plane of the image\n"
+"\n"
+"string format        # Specifies the format of the data\n"
+"                     #   Acceptable values:\n"
+"                     #     jpeg, png\n"
+"uint8[] data         # Compressed image buffer\n"
+"\n"
+"================================================================================\n"
+"MSG: std_msgs/Header\n"
+"# Standard metadata for higher-level stamped data types.\n"
+"# This is generally used to communicate timestamped data \n"
+"# in a particular coordinate frame.\n"
+"# \n"
+"# sequence ID: consecutively increasing ID \n"
+"uint32 seq\n"
+"#Two-integer timestamp that is expressed as:\n"
+"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
+"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
+"# time-handling sugar is provided by the client library\n"
+"time stamp\n"
+"#Frame this data is associated with\n"
+"string frame_id\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::CompressedImage_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::CompressedImage_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.header);
+      stream.next(m.format);
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct CompressedImage_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::CompressedImage_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::CompressedImage_<ContainerAllocator>& v)
+  {
+    s << indent << "header: ";
+    s << std::endl;
+    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
+    s << indent << "format: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>::stream(s, indent + "  ", v.format);
+    s << indent << "data[]" << std::endl;
+    for (size_t i = 0; i < v.data.size(); ++i)
+    {
+      s << indent << "  data[" << i << "]: ";
+      Printer<uint8_t>::stream(s, indent + "  ", v.data[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_COMPRESSEDIMAGE_H

thirdparty/ros/include/sensor_msgs/FluidPressure.h

@@ -0,0 +1,241 @@
+// Generated by gencpp from file sensor_msgs/FluidPressure.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_FLUIDPRESSURE_H
+#define SENSOR_MSGS_MESSAGE_FLUIDPRESSURE_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <std_msgs/Header.h>
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct FluidPressure_
+{
+  typedef FluidPressure_<ContainerAllocator> Type;
+
+  FluidPressure_()
+    : header()
+    , fluid_pressure(0.0)
+    , variance(0.0)  {
+    }
+  FluidPressure_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , fluid_pressure(0.0)
+    , variance(0.0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
+  _header_type header;
+
+   typedef double _fluid_pressure_type;
+  _fluid_pressure_type fluid_pressure;
+
+   typedef double _variance_type;
+  _variance_type variance;
+
+
+
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::FluidPressure_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::FluidPressure_<ContainerAllocator> const> ConstPtr;
+
+}; // struct FluidPressure_
+
+typedef ::sensor_msgs::FluidPressure_<std::allocator<void> > FluidPressure;
+
+typedef boost::shared_ptr< ::sensor_msgs::FluidPressure > FluidPressurePtr;
+typedef boost::shared_ptr< ::sensor_msgs::FluidPressure const> FluidPressureConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::FluidPressure_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::FluidPressure_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::FluidPressure_<ContainerAllocator1> & lhs, const ::sensor_msgs::FluidPressure_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.fluid_pressure == rhs.fluid_pressure &&
+    lhs.variance == rhs.variance;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::FluidPressure_<ContainerAllocator1> & lhs, const ::sensor_msgs::FluidPressure_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::FluidPressure_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::FluidPressure_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::FluidPressure_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::FluidPressure_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::FluidPressure_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::FluidPressure_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::FluidPressure_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "804dc5cea1c5306d6a2eb80b9833befe";
+  }
+
+  static const char* value(const ::sensor_msgs::FluidPressure_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x804dc5cea1c5306dULL;
+  static const uint64_t static_value2 = 0x6a2eb80b9833befeULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::FluidPressure_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/FluidPressure";
+  }
+
+  static const char* value(const ::sensor_msgs::FluidPressure_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::FluidPressure_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return " # Single pressure reading.  This message is appropriate for measuring the\n"
+" # pressure inside of a fluid (air, water, etc).  This also includes\n"
+" # atmospheric or barometric pressure.\n"
+"\n"
+" # This message is not appropriate for force/pressure contact sensors.\n"
+"\n"
+" Header header           # timestamp of the measurement\n"
+"                         # frame_id is the location of the pressure sensor\n"
+"\n"
+" float64 fluid_pressure  # Absolute pressure reading in Pascals.\n"
+"\n"
+" float64 variance        # 0 is interpreted as variance unknown\n"
+"================================================================================\n"
+"MSG: std_msgs/Header\n"
+"# Standard metadata for higher-level stamped data types.\n"
+"# This is generally used to communicate timestamped data \n"
+"# in a particular coordinate frame.\n"
+"# \n"
+"# sequence ID: consecutively increasing ID \n"
+"uint32 seq\n"
+"#Two-integer timestamp that is expressed as:\n"
+"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
+"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
+"# time-handling sugar is provided by the client library\n"
+"time stamp\n"
+"#Frame this data is associated with\n"
+"string frame_id\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::FluidPressure_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::FluidPressure_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.header);
+      stream.next(m.fluid_pressure);
+      stream.next(m.variance);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct FluidPressure_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::FluidPressure_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::FluidPressure_<ContainerAllocator>& v)
+  {
+    s << indent << "header: ";
+    s << std::endl;
+    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
+    s << indent << "fluid_pressure: ";
+    Printer<double>::stream(s, indent + "  ", v.fluid_pressure);
+    s << indent << "variance: ";
+    Printer<double>::stream(s, indent + "  ", v.variance);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_FLUIDPRESSURE_H

thirdparty/ros/include/sensor_msgs/Illuminance.h

@@ -0,0 +1,250 @@
+// Generated by gencpp from file sensor_msgs/Illuminance.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_ILLUMINANCE_H
+#define SENSOR_MSGS_MESSAGE_ILLUMINANCE_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <std_msgs/Header.h>
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct Illuminance_
+{
+  typedef Illuminance_<ContainerAllocator> Type;
+
+  Illuminance_()
+    : header()
+    , illuminance(0.0)
+    , variance(0.0)  {
+    }
+  Illuminance_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , illuminance(0.0)
+    , variance(0.0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
+  _header_type header;
+
+   typedef double _illuminance_type;
+  _illuminance_type illuminance;
+
+   typedef double _variance_type;
+  _variance_type variance;
+
+
+
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::Illuminance_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::Illuminance_<ContainerAllocator> const> ConstPtr;
+
+}; // struct Illuminance_
+
+typedef ::sensor_msgs::Illuminance_<std::allocator<void> > Illuminance;
+
+typedef boost::shared_ptr< ::sensor_msgs::Illuminance > IlluminancePtr;
+typedef boost::shared_ptr< ::sensor_msgs::Illuminance const> IlluminanceConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::Illuminance_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::Illuminance_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::Illuminance_<ContainerAllocator1> & lhs, const ::sensor_msgs::Illuminance_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.illuminance == rhs.illuminance &&
+    lhs.variance == rhs.variance;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::Illuminance_<ContainerAllocator1> & lhs, const ::sensor_msgs::Illuminance_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::Illuminance_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::Illuminance_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::Illuminance_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::Illuminance_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::Illuminance_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::Illuminance_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::Illuminance_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "8cf5febb0952fca9d650c3d11a81a188";
+  }
+
+  static const char* value(const ::sensor_msgs::Illuminance_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x8cf5febb0952fca9ULL;
+  static const uint64_t static_value2 = 0xd650c3d11a81a188ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::Illuminance_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/Illuminance";
+  }
+
+  static const char* value(const ::sensor_msgs::Illuminance_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::Illuminance_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return " # Single photometric illuminance measurement.  Light should be assumed to be\n"
+" # measured along the sensor's x-axis (the area of detection is the y-z plane).\n"
+" # The illuminance should have a 0 or positive value and be received with\n"
+" # the sensor's +X axis pointing toward the light source.\n"
+"\n"
+" # Photometric illuminance is the measure of the human eye's sensitivity of the\n"
+" # intensity of light encountering or passing through a surface.\n"
+"\n"
+" # All other Photometric and Radiometric measurements should\n"
+" # not use this message.\n"
+" # This message cannot represent:\n"
+" # Luminous intensity (candela/light source output)\n"
+" # Luminance (nits/light output per area)\n"
+" # Irradiance (watt/area), etc.\n"
+"\n"
+" Header header           # timestamp is the time the illuminance was measured\n"
+"                         # frame_id is the location and direction of the reading\n"
+"\n"
+" float64 illuminance     # Measurement of the Photometric Illuminance in Lux.\n"
+"\n"
+" float64 variance        # 0 is interpreted as variance unknown\n"
+"================================================================================\n"
+"MSG: std_msgs/Header\n"
+"# Standard metadata for higher-level stamped data types.\n"
+"# This is generally used to communicate timestamped data \n"
+"# in a particular coordinate frame.\n"
+"# \n"
+"# sequence ID: consecutively increasing ID \n"
+"uint32 seq\n"
+"#Two-integer timestamp that is expressed as:\n"
+"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
+"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
+"# time-handling sugar is provided by the client library\n"
+"time stamp\n"
+"#Frame this data is associated with\n"
+"string frame_id\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::Illuminance_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::Illuminance_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.header);
+      stream.next(m.illuminance);
+      stream.next(m.variance);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct Illuminance_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::Illuminance_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::Illuminance_<ContainerAllocator>& v)
+  {
+    s << indent << "header: ";
+    s << std::endl;
+    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
+    s << indent << "illuminance: ";
+    Printer<double>::stream(s, indent + "  ", v.illuminance);
+    s << indent << "variance: ";
+    Printer<double>::stream(s, indent + "  ", v.variance);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_ILLUMINANCE_H

thirdparty/ros/include/sensor_msgs/Image.h

@@ -0,0 +1,297 @@
+// Generated by gencpp from file sensor_msgs/Image.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_IMAGE_H
+#define SENSOR_MSGS_MESSAGE_IMAGE_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <std_msgs/Header.h>
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct Image_
+{
+  typedef Image_<ContainerAllocator> Type;
+
+  Image_()
+    : header()
+    , height(0)
+    , width(0)
+    , encoding()
+    , is_bigendian(0)
+    , step(0)
+    , data()  {
+    }
+  Image_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , height(0)
+    , width(0)
+    , encoding(_alloc)
+    , is_bigendian(0)
+    , step(0)
+    , data(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
+  _header_type header;
+
+   typedef uint32_t _height_type;
+  _height_type height;
+
+   typedef uint32_t _width_type;
+  _width_type width;
+
+   typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _encoding_type;
+  _encoding_type encoding;
+
+   typedef uint8_t _is_bigendian_type;
+  _is_bigendian_type is_bigendian;
+
+   typedef uint32_t _step_type;
+  _step_type step;
+
+   typedef std::vector<uint8_t, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<uint8_t>> _data_type;
+  _data_type data;
+
+
+
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::Image_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::Image_<ContainerAllocator> const> ConstPtr;
+
+}; // struct Image_
+
+typedef ::sensor_msgs::Image_<std::allocator<void> > Image;
+
+typedef boost::shared_ptr< ::sensor_msgs::Image > ImagePtr;
+typedef boost::shared_ptr< ::sensor_msgs::Image const> ImageConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::Image_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::Image_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::Image_<ContainerAllocator1> & lhs, const ::sensor_msgs::Image_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.height == rhs.height &&
+    lhs.width == rhs.width &&
+    lhs.encoding == rhs.encoding &&
+    lhs.is_bigendian == rhs.is_bigendian &&
+    lhs.step == rhs.step &&
+    lhs.data == rhs.data;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::Image_<ContainerAllocator1> & lhs, const ::sensor_msgs::Image_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::Image_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::Image_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::Image_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::Image_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::Image_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::Image_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::Image_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "060021388200f6f0f447d0fcd9c64743";
+  }
+
+  static const char* value(const ::sensor_msgs::Image_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x060021388200f6f0ULL;
+  static const uint64_t static_value2 = 0xf447d0fcd9c64743ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::Image_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/Image";
+  }
+
+  static const char* value(const ::sensor_msgs::Image_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::Image_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# This message contains an uncompressed image\n"
+"# (0, 0) is at top-left corner of image\n"
+"#\n"
+"\n"
+"Header header        # Header timestamp should be acquisition time of image\n"
+"                     # Header frame_id should be optical frame of camera\n"
+"                     # origin of frame should be optical center of camera\n"
+"                     # +x should point to the right in the image\n"
+"                     # +y should point down in the image\n"
+"                     # +z should point into to plane of the image\n"
+"                     # If the frame_id here and the frame_id of the CameraInfo\n"
+"                     # message associated with the image conflict\n"
+"                     # the behavior is undefined\n"
+"\n"
+"uint32 height         # image height, that is, number of rows\n"
+"uint32 width          # image width, that is, number of columns\n"
+"\n"
+"# The legal values for encoding are in file src/image_encodings.cpp\n"
+"# If you want to standardize a new string format, join\n"
+"# ros-users@lists.sourceforge.net and send an email proposing a new encoding.\n"
+"\n"
+"string encoding       # Encoding of pixels -- channel meaning, ordering, size\n"
+"                      # taken from the list of strings in include/sensor_msgs/image_encodings.h\n"
+"\n"
+"uint8 is_bigendian    # is this data bigendian?\n"
+"uint32 step           # Full row length in bytes\n"
+"uint8[] data          # actual matrix data, size is (step * rows)\n"
+"\n"
+"================================================================================\n"
+"MSG: std_msgs/Header\n"
+"# Standard metadata for higher-level stamped data types.\n"
+"# This is generally used to communicate timestamped data \n"
+"# in a particular coordinate frame.\n"
+"# \n"
+"# sequence ID: consecutively increasing ID \n"
+"uint32 seq\n"
+"#Two-integer timestamp that is expressed as:\n"
+"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
+"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
+"# time-handling sugar is provided by the client library\n"
+"time stamp\n"
+"#Frame this data is associated with\n"
+"string frame_id\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::Image_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::Image_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.header);
+      stream.next(m.height);
+      stream.next(m.width);
+      stream.next(m.encoding);
+      stream.next(m.is_bigendian);
+      stream.next(m.step);
+      stream.next(m.data);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct Image_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::Image_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::Image_<ContainerAllocator>& v)
+  {
+    s << indent << "header: ";
+    s << std::endl;
+    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
+    s << indent << "height: ";
+    Printer<uint32_t>::stream(s, indent + "  ", v.height);
+    s << indent << "width: ";
+    Printer<uint32_t>::stream(s, indent + "  ", v.width);
+    s << indent << "encoding: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>::stream(s, indent + "  ", v.encoding);
+    s << indent << "is_bigendian: ";
+    Printer<uint8_t>::stream(s, indent + "  ", v.is_bigendian);
+    s << indent << "step: ";
+    Printer<uint32_t>::stream(s, indent + "  ", v.step);
+    s << indent << "data[]" << std::endl;
+    for (size_t i = 0; i < v.data.size(); ++i)
+    {
+      s << indent << "  data[" << i << "]: ";
+      Printer<uint8_t>::stream(s, indent + "  ", v.data[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_IMAGE_H

thirdparty/ros/include/sensor_msgs/Imu.h

@@ -0,0 +1,340 @@
+// Generated by gencpp from file sensor_msgs/Imu.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_IMU_H
+#define SENSOR_MSGS_MESSAGE_IMU_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <std_msgs/Header.h>
+#include <geometry_msgs/Quaternion.h>
+#include <geometry_msgs/Vector3.h>
+#include <geometry_msgs/Vector3.h>
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct Imu_
+{
+  typedef Imu_<ContainerAllocator> Type;
+
+  Imu_()
+    : header()
+    , orientation()
+    , orientation_covariance()
+    , angular_velocity()
+    , angular_velocity_covariance()
+    , linear_acceleration()
+    , linear_acceleration_covariance()  {
+      orientation_covariance.assign(0.0);
+
+      angular_velocity_covariance.assign(0.0);
+
+      linear_acceleration_covariance.assign(0.0);
+  }
+  Imu_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , orientation(_alloc)
+    , orientation_covariance()
+    , angular_velocity(_alloc)
+    , angular_velocity_covariance()
+    , linear_acceleration(_alloc)
+    , linear_acceleration_covariance()  {
+  (void)_alloc;
+      orientation_covariance.assign(0.0);
+
+      angular_velocity_covariance.assign(0.0);
+
+      linear_acceleration_covariance.assign(0.0);
+  }
+
+
+
+   typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
+  _header_type header;
+
+   typedef  ::geometry_msgs::Quaternion_<ContainerAllocator>  _orientation_type;
+  _orientation_type orientation;
+
+   typedef boost::array<double, 9>  _orientation_covariance_type;
+  _orientation_covariance_type orientation_covariance;
+
+   typedef  ::geometry_msgs::Vector3_<ContainerAllocator>  _angular_velocity_type;
+  _angular_velocity_type angular_velocity;
+
+   typedef boost::array<double, 9>  _angular_velocity_covariance_type;
+  _angular_velocity_covariance_type angular_velocity_covariance;
+
+   typedef  ::geometry_msgs::Vector3_<ContainerAllocator>  _linear_acceleration_type;
+  _linear_acceleration_type linear_acceleration;
+
+   typedef boost::array<double, 9>  _linear_acceleration_covariance_type;
+  _linear_acceleration_covariance_type linear_acceleration_covariance;
+
+
+
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::Imu_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::Imu_<ContainerAllocator> const> ConstPtr;
+
+}; // struct Imu_
+
+typedef ::sensor_msgs::Imu_<std::allocator<void> > Imu;
+
+typedef boost::shared_ptr< ::sensor_msgs::Imu > ImuPtr;
+typedef boost::shared_ptr< ::sensor_msgs::Imu const> ImuConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::Imu_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::Imu_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::Imu_<ContainerAllocator1> & lhs, const ::sensor_msgs::Imu_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.orientation == rhs.orientation &&
+    lhs.orientation_covariance == rhs.orientation_covariance &&
+    lhs.angular_velocity == rhs.angular_velocity &&
+    lhs.angular_velocity_covariance == rhs.angular_velocity_covariance &&
+    lhs.linear_acceleration == rhs.linear_acceleration &&
+    lhs.linear_acceleration_covariance == rhs.linear_acceleration_covariance;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::Imu_<ContainerAllocator1> & lhs, const ::sensor_msgs::Imu_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::Imu_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::Imu_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::Imu_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::Imu_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::Imu_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::Imu_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::Imu_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "6a62c6daae103f4ff57a132d6f95cec2";
+  }
+
+  static const char* value(const ::sensor_msgs::Imu_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x6a62c6daae103f4fULL;
+  static const uint64_t static_value2 = 0xf57a132d6f95cec2ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::Imu_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/Imu";
+  }
+
+  static const char* value(const ::sensor_msgs::Imu_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::Imu_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# This is a message to hold data from an IMU (Inertial Measurement Unit)\n"
+"#\n"
+"# Accelerations should be in m/s^2 (not in g's), and rotational velocity should be in rad/sec\n"
+"#\n"
+"# If the covariance of the measurement is known, it should be filled in (if all you know is the \n"
+"# variance of each measurement, e.g. from the datasheet, just put those along the diagonal)\n"
+"# A covariance matrix of all zeros will be interpreted as \"covariance unknown\", and to use the\n"
+"# data a covariance will have to be assumed or gotten from some other source\n"
+"#\n"
+"# If you have no estimate for one of the data elements (e.g. your IMU doesn't produce an orientation \n"
+"# estimate), please set element 0 of the associated covariance matrix to -1\n"
+"# If you are interpreting this message, please check for a value of -1 in the first element of each \n"
+"# covariance matrix, and disregard the associated estimate.\n"
+"\n"
+"Header header\n"
+"\n"
+"geometry_msgs/Quaternion orientation\n"
+"float64[9] orientation_covariance # Row major about x, y, z axes\n"
+"\n"
+"geometry_msgs/Vector3 angular_velocity\n"
+"float64[9] angular_velocity_covariance # Row major about x, y, z axes\n"
+"\n"
+"geometry_msgs/Vector3 linear_acceleration\n"
+"float64[9] linear_acceleration_covariance # Row major x, y z \n"
+"\n"
+"================================================================================\n"
+"MSG: std_msgs/Header\n"
+"# Standard metadata for higher-level stamped data types.\n"
+"# This is generally used to communicate timestamped data \n"
+"# in a particular coordinate frame.\n"
+"# \n"
+"# sequence ID: consecutively increasing ID \n"
+"uint32 seq\n"
+"#Two-integer timestamp that is expressed as:\n"
+"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
+"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
+"# time-handling sugar is provided by the client library\n"
+"time stamp\n"
+"#Frame this data is associated with\n"
+"string frame_id\n"
+"\n"
+"================================================================================\n"
+"MSG: geometry_msgs/Quaternion\n"
+"# This represents an orientation in free space in quaternion form.\n"
+"\n"
+"float64 x\n"
+"float64 y\n"
+"float64 z\n"
+"float64 w\n"
+"\n"
+"================================================================================\n"
+"MSG: geometry_msgs/Vector3\n"
+"# This represents a vector in free space. \n"
+"# It is only meant to represent a direction. Therefore, it does not\n"
+"# make sense to apply a translation to it (e.g., when applying a \n"
+"# generic rigid transformation to a Vector3, tf2 will only apply the\n"
+"# rotation). If you want your data to be translatable too, use the\n"
+"# geometry_msgs/Point message instead.\n"
+"\n"
+"float64 x\n"
+"float64 y\n"
+"float64 z\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::Imu_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::Imu_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.header);
+      stream.next(m.orientation);
+      stream.next(m.orientation_covariance);
+      stream.next(m.angular_velocity);
+      stream.next(m.angular_velocity_covariance);
+      stream.next(m.linear_acceleration);
+      stream.next(m.linear_acceleration_covariance);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct Imu_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::Imu_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::Imu_<ContainerAllocator>& v)
+  {
+    s << indent << "header: ";
+    s << std::endl;
+    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
+    s << indent << "orientation: ";
+    s << std::endl;
+    Printer< ::geometry_msgs::Quaternion_<ContainerAllocator> >::stream(s, indent + "  ", v.orientation);
+    s << indent << "orientation_covariance[]" << std::endl;
+    for (size_t i = 0; i < v.orientation_covariance.size(); ++i)
+    {
+      s << indent << "  orientation_covariance[" << i << "]: ";
+      Printer<double>::stream(s, indent + "  ", v.orientation_covariance[i]);
+    }
+    s << indent << "angular_velocity: ";
+    s << std::endl;
+    Printer< ::geometry_msgs::Vector3_<ContainerAllocator> >::stream(s, indent + "  ", v.angular_velocity);
+    s << indent << "angular_velocity_covariance[]" << std::endl;
+    for (size_t i = 0; i < v.angular_velocity_covariance.size(); ++i)
+    {
+      s << indent << "  angular_velocity_covariance[" << i << "]: ";
+      Printer<double>::stream(s, indent + "  ", v.angular_velocity_covariance[i]);
+    }
+    s << indent << "linear_acceleration: ";
+    s << std::endl;
+    Printer< ::geometry_msgs::Vector3_<ContainerAllocator> >::stream(s, indent + "  ", v.linear_acceleration);
+    s << indent << "linear_acceleration_covariance[]" << std::endl;
+    for (size_t i = 0; i < v.linear_acceleration_covariance.size(); ++i)
+    {
+      s << indent << "  linear_acceleration_covariance[" << i << "]: ";
+      Printer<double>::stream(s, indent + "  ", v.linear_acceleration_covariance[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_IMU_H

thirdparty/ros/include/sensor_msgs/JointState.h

@@ -0,0 +1,290 @@
+// Generated by gencpp from file sensor_msgs/JointState.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_JOINTSTATE_H
+#define SENSOR_MSGS_MESSAGE_JOINTSTATE_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <std_msgs/Header.h>
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct JointState_
+{
+  typedef JointState_<ContainerAllocator> Type;
+
+  JointState_()
+    : header()
+    , name()
+    , position()
+    , velocity()
+    , effort()  {
+    }
+  JointState_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , name(_alloc)
+    , position(_alloc)
+    , velocity(_alloc)
+    , effort(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
+  _header_type header;
+
+   typedef std::vector<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>> _name_type;
+  _name_type name;
+
+   typedef std::vector<double, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<double>> _position_type;
+  _position_type position;
+
+   typedef std::vector<double, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<double>> _velocity_type;
+  _velocity_type velocity;
+
+   typedef std::vector<double, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<double>> _effort_type;
+  _effort_type effort;
+
+
+
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::JointState_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::JointState_<ContainerAllocator> const> ConstPtr;
+
+}; // struct JointState_
+
+typedef ::sensor_msgs::JointState_<std::allocator<void> > JointState;
+
+typedef boost::shared_ptr< ::sensor_msgs::JointState > JointStatePtr;
+typedef boost::shared_ptr< ::sensor_msgs::JointState const> JointStateConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::JointState_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::JointState_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::JointState_<ContainerAllocator1> & lhs, const ::sensor_msgs::JointState_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.name == rhs.name &&
+    lhs.position == rhs.position &&
+    lhs.velocity == rhs.velocity &&
+    lhs.effort == rhs.effort;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::JointState_<ContainerAllocator1> & lhs, const ::sensor_msgs::JointState_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::JointState_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::JointState_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::JointState_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::JointState_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::JointState_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::JointState_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::JointState_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "3066dcd76a6cfaef579bd0f34173e9fd";
+  }
+
+  static const char* value(const ::sensor_msgs::JointState_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x3066dcd76a6cfaefULL;
+  static const uint64_t static_value2 = 0x579bd0f34173e9fdULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::JointState_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/JointState";
+  }
+
+  static const char* value(const ::sensor_msgs::JointState_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::JointState_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# This is a message that holds data to describe the state of a set of torque controlled joints. \n"
+"#\n"
+"# The state of each joint (revolute or prismatic) is defined by:\n"
+"#  * the position of the joint (rad or m),\n"
+"#  * the velocity of the joint (rad/s or m/s) and \n"
+"#  * the effort that is applied in the joint (Nm or N).\n"
+"#\n"
+"# Each joint is uniquely identified by its name\n"
+"# The header specifies the time at which the joint states were recorded. All the joint states\n"
+"# in one message have to be recorded at the same time.\n"
+"#\n"
+"# This message consists of a multiple arrays, one for each part of the joint state. \n"
+"# The goal is to make each of the fields optional. When e.g. your joints have no\n"
+"# effort associated with them, you can leave the effort array empty. \n"
+"#\n"
+"# All arrays in this message should have the same size, or be empty.\n"
+"# This is the only way to uniquely associate the joint name with the correct\n"
+"# states.\n"
+"\n"
+"\n"
+"Header header\n"
+"\n"
+"string[] name\n"
+"float64[] position\n"
+"float64[] velocity\n"
+"float64[] effort\n"
+"\n"
+"================================================================================\n"
+"MSG: std_msgs/Header\n"
+"# Standard metadata for higher-level stamped data types.\n"
+"# This is generally used to communicate timestamped data \n"
+"# in a particular coordinate frame.\n"
+"# \n"
+"# sequence ID: consecutively increasing ID \n"
+"uint32 seq\n"
+"#Two-integer timestamp that is expressed as:\n"
+"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
+"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
+"# time-handling sugar is provided by the client library\n"
+"time stamp\n"
+"#Frame this data is associated with\n"
+"string frame_id\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::JointState_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::JointState_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.header);
+      stream.next(m.name);
+      stream.next(m.position);
+      stream.next(m.velocity);
+      stream.next(m.effort);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct JointState_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::JointState_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::JointState_<ContainerAllocator>& v)
+  {
+    s << indent << "header: ";
+    s << std::endl;
+    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
+    s << indent << "name[]" << std::endl;
+    for (size_t i = 0; i < v.name.size(); ++i)
+    {
+      s << indent << "  name[" << i << "]: ";
+      Printer<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>::stream(s, indent + "  ", v.name[i]);
+    }
+    s << indent << "position[]" << std::endl;
+    for (size_t i = 0; i < v.position.size(); ++i)
+    {
+      s << indent << "  position[" << i << "]: ";
+      Printer<double>::stream(s, indent + "  ", v.position[i]);
+    }
+    s << indent << "velocity[]" << std::endl;
+    for (size_t i = 0; i < v.velocity.size(); ++i)
+    {
+      s << indent << "  velocity[" << i << "]: ";
+      Printer<double>::stream(s, indent + "  ", v.velocity[i]);
+    }
+    s << indent << "effort[]" << std::endl;
+    for (size_t i = 0; i < v.effort.size(); ++i)
+    {
+      s << indent << "  effort[" << i << "]: ";
+      Printer<double>::stream(s, indent + "  ", v.effort[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_JOINTSTATE_H

thirdparty/ros/include/sensor_msgs/Joy.h

@@ -0,0 +1,242 @@
+// Generated by gencpp from file sensor_msgs/Joy.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_JOY_H
+#define SENSOR_MSGS_MESSAGE_JOY_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <std_msgs/Header.h>
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct Joy_
+{
+  typedef Joy_<ContainerAllocator> Type;
+
+  Joy_()
+    : header()
+    , axes()
+    , buttons()  {
+    }
+  Joy_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , axes(_alloc)
+    , buttons(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
+  _header_type header;
+
+   typedef std::vector<float, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<float>> _axes_type;
+  _axes_type axes;
+
+   typedef std::vector<int32_t, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<int32_t>> _buttons_type;
+  _buttons_type buttons;
+
+
+
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::Joy_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::Joy_<ContainerAllocator> const> ConstPtr;
+
+}; // struct Joy_
+
+typedef ::sensor_msgs::Joy_<std::allocator<void> > Joy;
+
+typedef boost::shared_ptr< ::sensor_msgs::Joy > JoyPtr;
+typedef boost::shared_ptr< ::sensor_msgs::Joy const> JoyConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::Joy_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::Joy_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::Joy_<ContainerAllocator1> & lhs, const ::sensor_msgs::Joy_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.axes == rhs.axes &&
+    lhs.buttons == rhs.buttons;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::Joy_<ContainerAllocator1> & lhs, const ::sensor_msgs::Joy_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::Joy_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::Joy_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::Joy_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::Joy_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::Joy_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::Joy_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::Joy_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "5a9ea5f83505693b71e785041e67a8bb";
+  }
+
+  static const char* value(const ::sensor_msgs::Joy_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x5a9ea5f83505693bULL;
+  static const uint64_t static_value2 = 0x71e785041e67a8bbULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::Joy_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/Joy";
+  }
+
+  static const char* value(const ::sensor_msgs::Joy_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::Joy_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# Reports the state of a joysticks axes and buttons.\n"
+"Header header           # timestamp in the header is the time the data is received from the joystick\n"
+"float32[] axes          # the axes measurements from a joystick\n"
+"int32[] buttons         # the buttons measurements from a joystick \n"
+"\n"
+"================================================================================\n"
+"MSG: std_msgs/Header\n"
+"# Standard metadata for higher-level stamped data types.\n"
+"# This is generally used to communicate timestamped data \n"
+"# in a particular coordinate frame.\n"
+"# \n"
+"# sequence ID: consecutively increasing ID \n"
+"uint32 seq\n"
+"#Two-integer timestamp that is expressed as:\n"
+"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
+"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
+"# time-handling sugar is provided by the client library\n"
+"time stamp\n"
+"#Frame this data is associated with\n"
+"string frame_id\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::Joy_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::Joy_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.header);
+      stream.next(m.axes);
+      stream.next(m.buttons);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct Joy_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::Joy_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::Joy_<ContainerAllocator>& v)
+  {
+    s << indent << "header: ";
+    s << std::endl;
+    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
+    s << indent << "axes[]" << std::endl;
+    for (size_t i = 0; i < v.axes.size(); ++i)
+    {
+      s << indent << "  axes[" << i << "]: ";
+      Printer<float>::stream(s, indent + "  ", v.axes[i]);
+    }
+    s << indent << "buttons[]" << std::endl;
+    for (size_t i = 0; i < v.buttons.size(); ++i)
+    {
+      s << indent << "  buttons[" << i << "]: ";
+      Printer<int32_t>::stream(s, indent + "  ", v.buttons[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_JOY_H

thirdparty/ros/include/sensor_msgs/JoyFeedback.h

@@ -0,0 +1,249 @@
+// Generated by gencpp from file sensor_msgs/JoyFeedback.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_JOYFEEDBACK_H
+#define SENSOR_MSGS_MESSAGE_JOYFEEDBACK_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct JoyFeedback_
+{
+  typedef JoyFeedback_<ContainerAllocator> Type;
+
+  JoyFeedback_()
+    : type(0)
+    , id(0)
+    , intensity(0.0)  {
+    }
+  JoyFeedback_(const ContainerAllocator& _alloc)
+    : type(0)
+    , id(0)
+    , intensity(0.0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef uint8_t _type_type;
+  _type_type type;
+
+   typedef uint8_t _id_type;
+  _id_type id;
+
+   typedef float _intensity_type;
+  _intensity_type intensity;
+
+
+
+// reducing the odds to have name collisions with Windows.h 
+#if defined(_WIN32) && defined(TYPE_LED)
+  #undef TYPE_LED
+#endif
+#if defined(_WIN32) && defined(TYPE_RUMBLE)
+  #undef TYPE_RUMBLE
+#endif
+#if defined(_WIN32) && defined(TYPE_BUZZER)
+  #undef TYPE_BUZZER
+#endif
+
+  enum {
+    TYPE_LED = 0u,
+    TYPE_RUMBLE = 1u,
+    TYPE_BUZZER = 2u,
+  };
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::JoyFeedback_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::JoyFeedback_<ContainerAllocator> const> ConstPtr;
+
+}; // struct JoyFeedback_
+
+typedef ::sensor_msgs::JoyFeedback_<std::allocator<void> > JoyFeedback;
+
+typedef boost::shared_ptr< ::sensor_msgs::JoyFeedback > JoyFeedbackPtr;
+typedef boost::shared_ptr< ::sensor_msgs::JoyFeedback const> JoyFeedbackConstPtr;
+
+// constants requiring out of line definition
+
+   
+
+   
+
+   
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::JoyFeedback_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::JoyFeedback_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::JoyFeedback_<ContainerAllocator1> & lhs, const ::sensor_msgs::JoyFeedback_<ContainerAllocator2> & rhs)
+{
+  return lhs.type == rhs.type &&
+    lhs.id == rhs.id &&
+    lhs.intensity == rhs.intensity;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::JoyFeedback_<ContainerAllocator1> & lhs, const ::sensor_msgs::JoyFeedback_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::JoyFeedback_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::JoyFeedback_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::JoyFeedback_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::JoyFeedback_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::JoyFeedback_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::JoyFeedback_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::JoyFeedback_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "f4dcd73460360d98f36e55ee7f2e46f1";
+  }
+
+  static const char* value(const ::sensor_msgs::JoyFeedback_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0xf4dcd73460360d98ULL;
+  static const uint64_t static_value2 = 0xf36e55ee7f2e46f1ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::JoyFeedback_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/JoyFeedback";
+  }
+
+  static const char* value(const ::sensor_msgs::JoyFeedback_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::JoyFeedback_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# Declare of the type of feedback\n"
+"uint8 TYPE_LED    = 0\n"
+"uint8 TYPE_RUMBLE = 1\n"
+"uint8 TYPE_BUZZER = 2\n"
+"\n"
+"uint8 type\n"
+"\n"
+"# This will hold an id number for each type of each feedback.\n"
+"# Example, the first led would be id=0, the second would be id=1\n"
+"uint8 id\n"
+"\n"
+"# Intensity of the feedback, from 0.0 to 1.0, inclusive.  If device is\n"
+"# actually binary, driver should treat 0<=x<0.5 as off, 0.5<=x<=1 as on.\n"
+"float32 intensity\n"
+"\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::JoyFeedback_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::JoyFeedback_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.type);
+      stream.next(m.id);
+      stream.next(m.intensity);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct JoyFeedback_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::JoyFeedback_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::JoyFeedback_<ContainerAllocator>& v)
+  {
+    s << indent << "type: ";
+    Printer<uint8_t>::stream(s, indent + "  ", v.type);
+    s << indent << "id: ";
+    Printer<uint8_t>::stream(s, indent + "  ", v.id);
+    s << indent << "intensity: ";
+    Printer<float>::stream(s, indent + "  ", v.intensity);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_JOYFEEDBACK_H

thirdparty/ros/include/sensor_msgs/JoyFeedbackArray.h

@@ -0,0 +1,220 @@
+// Generated by gencpp from file sensor_msgs/JoyFeedbackArray.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_JOYFEEDBACKARRAY_H
+#define SENSOR_MSGS_MESSAGE_JOYFEEDBACKARRAY_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <sensor_msgs/JoyFeedback.h>
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct JoyFeedbackArray_
+{
+  typedef JoyFeedbackArray_<ContainerAllocator> Type;
+
+  JoyFeedbackArray_()
+    : array()  {
+    }
+  JoyFeedbackArray_(const ContainerAllocator& _alloc)
+    : array(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef std::vector< ::sensor_msgs::JoyFeedback_<ContainerAllocator> , typename std::allocator_traits<ContainerAllocator>::template rebind_alloc< ::sensor_msgs::JoyFeedback_<ContainerAllocator> >> _array_type;
+  _array_type array;
+
+
+
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> const> ConstPtr;
+
+}; // struct JoyFeedbackArray_
+
+typedef ::sensor_msgs::JoyFeedbackArray_<std::allocator<void> > JoyFeedbackArray;
+
+typedef boost::shared_ptr< ::sensor_msgs::JoyFeedbackArray > JoyFeedbackArrayPtr;
+typedef boost::shared_ptr< ::sensor_msgs::JoyFeedbackArray const> JoyFeedbackArrayConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator1> & lhs, const ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator2> & rhs)
+{
+  return lhs.array == rhs.array;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator1> & lhs, const ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cde5730a895b1fc4dee6f91b754b213d";
+  }
+
+  static const char* value(const ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0xcde5730a895b1fc4ULL;
+  static const uint64_t static_value2 = 0xdee6f91b754b213dULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/JoyFeedbackArray";
+  }
+
+  static const char* value(const ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# This message publishes values for multiple feedback at once. \n"
+"JoyFeedback[] array\n"
+"================================================================================\n"
+"MSG: sensor_msgs/JoyFeedback\n"
+"# Declare of the type of feedback\n"
+"uint8 TYPE_LED    = 0\n"
+"uint8 TYPE_RUMBLE = 1\n"
+"uint8 TYPE_BUZZER = 2\n"
+"\n"
+"uint8 type\n"
+"\n"
+"# This will hold an id number for each type of each feedback.\n"
+"# Example, the first led would be id=0, the second would be id=1\n"
+"uint8 id\n"
+"\n"
+"# Intensity of the feedback, from 0.0 to 1.0, inclusive.  If device is\n"
+"# actually binary, driver should treat 0<=x<0.5 as off, 0.5<=x<=1 as on.\n"
+"float32 intensity\n"
+"\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.array);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct JoyFeedbackArray_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator>& v)
+  {
+    s << indent << "array[]" << std::endl;
+    for (size_t i = 0; i < v.array.size(); ++i)
+    {
+      s << indent << "  array[" << i << "]: ";
+      s << std::endl;
+      s << indent;
+      Printer< ::sensor_msgs::JoyFeedback_<ContainerAllocator> >::stream(s, indent + "    ", v.array[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_JOYFEEDBACKARRAY_H

thirdparty/ros/include/sensor_msgs/LaserEcho.h

@@ -0,0 +1,203 @@
+// Generated by gencpp from file sensor_msgs/LaserEcho.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_LASERECHO_H
+#define SENSOR_MSGS_MESSAGE_LASERECHO_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct LaserEcho_
+{
+  typedef LaserEcho_<ContainerAllocator> Type;
+
+  LaserEcho_()
+    : echoes()  {
+    }
+  LaserEcho_(const ContainerAllocator& _alloc)
+    : echoes(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef std::vector<float, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<float>> _echoes_type;
+  _echoes_type echoes;
+
+
+
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::LaserEcho_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::LaserEcho_<ContainerAllocator> const> ConstPtr;
+
+}; // struct LaserEcho_
+
+typedef ::sensor_msgs::LaserEcho_<std::allocator<void> > LaserEcho;
+
+typedef boost::shared_ptr< ::sensor_msgs::LaserEcho > LaserEchoPtr;
+typedef boost::shared_ptr< ::sensor_msgs::LaserEcho const> LaserEchoConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::LaserEcho_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::LaserEcho_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::LaserEcho_<ContainerAllocator1> & lhs, const ::sensor_msgs::LaserEcho_<ContainerAllocator2> & rhs)
+{
+  return lhs.echoes == rhs.echoes;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::LaserEcho_<ContainerAllocator1> & lhs, const ::sensor_msgs::LaserEcho_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::LaserEcho_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::LaserEcho_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::LaserEcho_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::LaserEcho_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::LaserEcho_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::LaserEcho_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::LaserEcho_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "8bc5ae449b200fba4d552b4225586696";
+  }
+
+  static const char* value(const ::sensor_msgs::LaserEcho_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x8bc5ae449b200fbaULL;
+  static const uint64_t static_value2 = 0x4d552b4225586696ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::LaserEcho_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/LaserEcho";
+  }
+
+  static const char* value(const ::sensor_msgs::LaserEcho_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::LaserEcho_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# This message is a submessage of MultiEchoLaserScan and is not intended\n"
+"# to be used separately.\n"
+"\n"
+"float32[] echoes  # Multiple values of ranges or intensities.\n"
+"                  # Each array represents data from the same angle increment.\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::LaserEcho_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::LaserEcho_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.echoes);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct LaserEcho_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::LaserEcho_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::LaserEcho_<ContainerAllocator>& v)
+  {
+    s << indent << "echoes[]" << std::endl;
+    for (size_t i = 0; i < v.echoes.size(); ++i)
+    {
+      s << indent << "  echoes[" << i << "]: ";
+      Printer<float>::stream(s, indent + "  ", v.echoes[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_LASERECHO_H

thirdparty/ros/include/sensor_msgs/LaserScan.h

@@ -0,0 +1,330 @@
+// Generated by gencpp from file sensor_msgs/LaserScan.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_LASERSCAN_H
+#define SENSOR_MSGS_MESSAGE_LASERSCAN_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <std_msgs/Header.h>
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct LaserScan_
+{
+  typedef LaserScan_<ContainerAllocator> Type;
+
+  LaserScan_()
+    : header()
+    , angle_min(0.0)
+    , angle_max(0.0)
+    , angle_increment(0.0)
+    , time_increment(0.0)
+    , scan_time(0.0)
+    , range_min(0.0)
+    , range_max(0.0)
+    , ranges()
+    , intensities()  {
+    }
+  LaserScan_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , angle_min(0.0)
+    , angle_max(0.0)
+    , angle_increment(0.0)
+    , time_increment(0.0)
+    , scan_time(0.0)
+    , range_min(0.0)
+    , range_max(0.0)
+    , ranges(_alloc)
+    , intensities(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
+  _header_type header;
+
+   typedef float _angle_min_type;
+  _angle_min_type angle_min;
+
+   typedef float _angle_max_type;
+  _angle_max_type angle_max;
+
+   typedef float _angle_increment_type;
+  _angle_increment_type angle_increment;
+
+   typedef float _time_increment_type;
+  _time_increment_type time_increment;
+
+   typedef float _scan_time_type;
+  _scan_time_type scan_time;
+
+   typedef float _range_min_type;
+  _range_min_type range_min;
+
+   typedef float _range_max_type;
+  _range_max_type range_max;
+
+   typedef std::vector<float, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<float>> _ranges_type;
+  _ranges_type ranges;
+
+   typedef std::vector<float, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<float>> _intensities_type;
+  _intensities_type intensities;
+
+
+
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::LaserScan_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::LaserScan_<ContainerAllocator> const> ConstPtr;
+
+}; // struct LaserScan_
+
+typedef ::sensor_msgs::LaserScan_<std::allocator<void> > LaserScan;
+
+typedef boost::shared_ptr< ::sensor_msgs::LaserScan > LaserScanPtr;
+typedef boost::shared_ptr< ::sensor_msgs::LaserScan const> LaserScanConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::LaserScan_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::LaserScan_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::LaserScan_<ContainerAllocator1> & lhs, const ::sensor_msgs::LaserScan_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.angle_min == rhs.angle_min &&
+    lhs.angle_max == rhs.angle_max &&
+    lhs.angle_increment == rhs.angle_increment &&
+    lhs.time_increment == rhs.time_increment &&
+    lhs.scan_time == rhs.scan_time &&
+    lhs.range_min == rhs.range_min &&
+    lhs.range_max == rhs.range_max &&
+    lhs.ranges == rhs.ranges &&
+    lhs.intensities == rhs.intensities;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::LaserScan_<ContainerAllocator1> & lhs, const ::sensor_msgs::LaserScan_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::LaserScan_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::LaserScan_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::LaserScan_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::LaserScan_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::LaserScan_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::LaserScan_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::LaserScan_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "90c7ef2dc6895d81024acba2ac42f369";
+  }
+
+  static const char* value(const ::sensor_msgs::LaserScan_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x90c7ef2dc6895d81ULL;
+  static const uint64_t static_value2 = 0x024acba2ac42f369ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::LaserScan_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/LaserScan";
+  }
+
+  static const char* value(const ::sensor_msgs::LaserScan_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::LaserScan_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# Single scan from a planar laser range-finder\n"
+"#\n"
+"# If you have another ranging device with different behavior (e.g. a sonar\n"
+"# array), please find or create a different message, since applications\n"
+"# will make fairly laser-specific assumptions about this data\n"
+"\n"
+"Header header            # timestamp in the header is the acquisition time of \n"
+"                         # the first ray in the scan.\n"
+"                         #\n"
+"                         # in frame frame_id, angles are measured around \n"
+"                         # the positive Z axis (counterclockwise, if Z is up)\n"
+"                         # with zero angle being forward along the x axis\n"
+"                         \n"
+"float32 angle_min        # start angle of the scan [rad]\n"
+"float32 angle_max        # end angle of the scan [rad]\n"
+"float32 angle_increment  # angular distance between measurements [rad]\n"
+"\n"
+"float32 time_increment   # time between measurements [seconds] - if your scanner\n"
+"                         # is moving, this will be used in interpolating position\n"
+"                         # of 3d points\n"
+"float32 scan_time        # time between scans [seconds]\n"
+"\n"
+"float32 range_min        # minimum range value [m]\n"
+"float32 range_max        # maximum range value [m]\n"
+"\n"
+"float32[] ranges         # range data [m] (Note: values < range_min or > range_max should be discarded)\n"
+"float32[] intensities    # intensity data [device-specific units].  If your\n"
+"                         # device does not provide intensities, please leave\n"
+"                         # the array empty.\n"
+"\n"
+"================================================================================\n"
+"MSG: std_msgs/Header\n"
+"# Standard metadata for higher-level stamped data types.\n"
+"# This is generally used to communicate timestamped data \n"
+"# in a particular coordinate frame.\n"
+"# \n"
+"# sequence ID: consecutively increasing ID \n"
+"uint32 seq\n"
+"#Two-integer timestamp that is expressed as:\n"
+"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
+"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
+"# time-handling sugar is provided by the client library\n"
+"time stamp\n"
+"#Frame this data is associated with\n"
+"string frame_id\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::LaserScan_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::LaserScan_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.header);
+      stream.next(m.angle_min);
+      stream.next(m.angle_max);
+      stream.next(m.angle_increment);
+      stream.next(m.time_increment);
+      stream.next(m.scan_time);
+      stream.next(m.range_min);
+      stream.next(m.range_max);
+      stream.next(m.ranges);
+      stream.next(m.intensities);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct LaserScan_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::LaserScan_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::LaserScan_<ContainerAllocator>& v)
+  {
+    s << indent << "header: ";
+    s << std::endl;
+    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
+    s << indent << "angle_min: ";
+    Printer<float>::stream(s, indent + "  ", v.angle_min);
+    s << indent << "angle_max: ";
+    Printer<float>::stream(s, indent + "  ", v.angle_max);
+    s << indent << "angle_increment: ";
+    Printer<float>::stream(s, indent + "  ", v.angle_increment);
+    s << indent << "time_increment: ";
+    Printer<float>::stream(s, indent + "  ", v.time_increment);
+    s << indent << "scan_time: ";
+    Printer<float>::stream(s, indent + "  ", v.scan_time);
+    s << indent << "range_min: ";
+    Printer<float>::stream(s, indent + "  ", v.range_min);
+    s << indent << "range_max: ";
+    Printer<float>::stream(s, indent + "  ", v.range_max);
+    s << indent << "ranges[]" << std::endl;
+    for (size_t i = 0; i < v.ranges.size(); ++i)
+    {
+      s << indent << "  ranges[" << i << "]: ";
+      Printer<float>::stream(s, indent + "  ", v.ranges[i]);
+    }
+    s << indent << "intensities[]" << std::endl;
+    for (size_t i = 0; i < v.intensities.size(); ++i)
+    {
+      s << indent << "  intensities[" << i << "]: ";
+      Printer<float>::stream(s, indent + "  ", v.intensities[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_LASERSCAN_H

thirdparty/ros/include/sensor_msgs/MagneticField.h

@@ -0,0 +1,272 @@
+// Generated by gencpp from file sensor_msgs/MagneticField.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_MAGNETICFIELD_H
+#define SENSOR_MSGS_MESSAGE_MAGNETICFIELD_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <std_msgs/Header.h>
+#include <geometry_msgs/Vector3.h>
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct MagneticField_
+{
+  typedef MagneticField_<ContainerAllocator> Type;
+
+  MagneticField_()
+    : header()
+    , magnetic_field()
+    , magnetic_field_covariance()  {
+      magnetic_field_covariance.assign(0.0);
+  }
+  MagneticField_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , magnetic_field(_alloc)
+    , magnetic_field_covariance()  {
+  (void)_alloc;
+      magnetic_field_covariance.assign(0.0);
+  }
+
+
+
+   typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
+  _header_type header;
+
+   typedef  ::geometry_msgs::Vector3_<ContainerAllocator>  _magnetic_field_type;
+  _magnetic_field_type magnetic_field;
+
+   typedef boost::array<double, 9>  _magnetic_field_covariance_type;
+  _magnetic_field_covariance_type magnetic_field_covariance;
+
+
+
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::MagneticField_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::MagneticField_<ContainerAllocator> const> ConstPtr;
+
+}; // struct MagneticField_
+
+typedef ::sensor_msgs::MagneticField_<std::allocator<void> > MagneticField;
+
+typedef boost::shared_ptr< ::sensor_msgs::MagneticField > MagneticFieldPtr;
+typedef boost::shared_ptr< ::sensor_msgs::MagneticField const> MagneticFieldConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::MagneticField_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::MagneticField_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::MagneticField_<ContainerAllocator1> & lhs, const ::sensor_msgs::MagneticField_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.magnetic_field == rhs.magnetic_field &&
+    lhs.magnetic_field_covariance == rhs.magnetic_field_covariance;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::MagneticField_<ContainerAllocator1> & lhs, const ::sensor_msgs::MagneticField_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::MagneticField_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::MagneticField_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::MagneticField_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::MagneticField_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::MagneticField_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::MagneticField_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::MagneticField_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "2f3b0b43eed0c9501de0fa3ff89a45aa";
+  }
+
+  static const char* value(const ::sensor_msgs::MagneticField_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x2f3b0b43eed0c950ULL;
+  static const uint64_t static_value2 = 0x1de0fa3ff89a45aaULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::MagneticField_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/MagneticField";
+  }
+
+  static const char* value(const ::sensor_msgs::MagneticField_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::MagneticField_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return " # Measurement of the Magnetic Field vector at a specific location.\n"
+"\n"
+" # If the covariance of the measurement is known, it should be filled in\n"
+" # (if all you know is the variance of each measurement, e.g. from the datasheet,\n"
+" #just put those along the diagonal)\n"
+" # A covariance matrix of all zeros will be interpreted as \"covariance unknown\",\n"
+" # and to use the data a covariance will have to be assumed or gotten from some\n"
+" # other source\n"
+"\n"
+"\n"
+" Header header                        # timestamp is the time the\n"
+"                                      # field was measured\n"
+"                                      # frame_id is the location and orientation\n"
+"                                      # of the field measurement\n"
+"\n"
+" geometry_msgs/Vector3 magnetic_field # x, y, and z components of the\n"
+"                                      # field vector in Tesla\n"
+"                                      # If your sensor does not output 3 axes,\n"
+"                                      # put NaNs in the components not reported.\n"
+"\n"
+" float64[9] magnetic_field_covariance # Row major about x, y, z axes\n"
+"                                      # 0 is interpreted as variance unknown\n"
+"================================================================================\n"
+"MSG: std_msgs/Header\n"
+"# Standard metadata for higher-level stamped data types.\n"
+"# This is generally used to communicate timestamped data \n"
+"# in a particular coordinate frame.\n"
+"# \n"
+"# sequence ID: consecutively increasing ID \n"
+"uint32 seq\n"
+"#Two-integer timestamp that is expressed as:\n"
+"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
+"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
+"# time-handling sugar is provided by the client library\n"
+"time stamp\n"
+"#Frame this data is associated with\n"
+"string frame_id\n"
+"\n"
+"================================================================================\n"
+"MSG: geometry_msgs/Vector3\n"
+"# This represents a vector in free space. \n"
+"# It is only meant to represent a direction. Therefore, it does not\n"
+"# make sense to apply a translation to it (e.g., when applying a \n"
+"# generic rigid transformation to a Vector3, tf2 will only apply the\n"
+"# rotation). If you want your data to be translatable too, use the\n"
+"# geometry_msgs/Point message instead.\n"
+"\n"
+"float64 x\n"
+"float64 y\n"
+"float64 z\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::MagneticField_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::MagneticField_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.header);
+      stream.next(m.magnetic_field);
+      stream.next(m.magnetic_field_covariance);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct MagneticField_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::MagneticField_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::MagneticField_<ContainerAllocator>& v)
+  {
+    s << indent << "header: ";
+    s << std::endl;
+    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
+    s << indent << "magnetic_field: ";
+    s << std::endl;
+    Printer< ::geometry_msgs::Vector3_<ContainerAllocator> >::stream(s, indent + "  ", v.magnetic_field);
+    s << indent << "magnetic_field_covariance[]" << std::endl;
+    for (size_t i = 0; i < v.magnetic_field_covariance.size(); ++i)
+    {
+      s << indent << "  magnetic_field_covariance[" << i << "]: ";
+      Printer<double>::stream(s, indent + "  ", v.magnetic_field_covariance[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_MAGNETICFIELD_H

thirdparty/ros/include/sensor_msgs/MultiDOFJointState.h

@@ -0,0 +1,340 @@
+// Generated by gencpp from file sensor_msgs/MultiDOFJointState.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_MULTIDOFJOINTSTATE_H
+#define SENSOR_MSGS_MESSAGE_MULTIDOFJOINTSTATE_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <std_msgs/Header.h>
+#include <geometry_msgs/Transform.h>
+#include <geometry_msgs/Twist.h>
+#include <geometry_msgs/Wrench.h>
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct MultiDOFJointState_
+{
+  typedef MultiDOFJointState_<ContainerAllocator> Type;
+
+  MultiDOFJointState_()
+    : header()
+    , joint_names()
+    , transforms()
+    , twist()
+    , wrench()  {
+    }
+  MultiDOFJointState_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , joint_names(_alloc)
+    , transforms(_alloc)
+    , twist(_alloc)
+    , wrench(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
+  _header_type header;
+
+   typedef std::vector<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>> _joint_names_type;
+  _joint_names_type joint_names;
+
+   typedef std::vector< ::geometry_msgs::Transform_<ContainerAllocator> , typename std::allocator_traits<ContainerAllocator>::template rebind_alloc< ::geometry_msgs::Transform_<ContainerAllocator> >> _transforms_type;
+  _transforms_type transforms;
+
+   typedef std::vector< ::geometry_msgs::Twist_<ContainerAllocator> , typename std::allocator_traits<ContainerAllocator>::template rebind_alloc< ::geometry_msgs::Twist_<ContainerAllocator> >> _twist_type;
+  _twist_type twist;
+
+   typedef std::vector< ::geometry_msgs::Wrench_<ContainerAllocator> , typename std::allocator_traits<ContainerAllocator>::template rebind_alloc< ::geometry_msgs::Wrench_<ContainerAllocator> >> _wrench_type;
+  _wrench_type wrench;
+
+
+
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> const> ConstPtr;
+
+}; // struct MultiDOFJointState_
+
+typedef ::sensor_msgs::MultiDOFJointState_<std::allocator<void> > MultiDOFJointState;
+
+typedef boost::shared_ptr< ::sensor_msgs::MultiDOFJointState > MultiDOFJointStatePtr;
+typedef boost::shared_ptr< ::sensor_msgs::MultiDOFJointState const> MultiDOFJointStateConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::MultiDOFJointState_<ContainerAllocator1> & lhs, const ::sensor_msgs::MultiDOFJointState_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.joint_names == rhs.joint_names &&
+    lhs.transforms == rhs.transforms &&
+    lhs.twist == rhs.twist &&
+    lhs.wrench == rhs.wrench;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::MultiDOFJointState_<ContainerAllocator1> & lhs, const ::sensor_msgs::MultiDOFJointState_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "690f272f0640d2631c305eeb8301e59d";
+  }
+
+  static const char* value(const ::sensor_msgs::MultiDOFJointState_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x690f272f0640d263ULL;
+  static const uint64_t static_value2 = 0x1c305eeb8301e59dULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/MultiDOFJointState";
+  }
+
+  static const char* value(const ::sensor_msgs::MultiDOFJointState_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# Representation of state for joints with multiple degrees of freedom, \n"
+"# following the structure of JointState.\n"
+"#\n"
+"# It is assumed that a joint in a system corresponds to a transform that gets applied \n"
+"# along the kinematic chain. For example, a planar joint (as in URDF) is 3DOF (x, y, yaw)\n"
+"# and those 3DOF can be expressed as a transformation matrix, and that transformation\n"
+"# matrix can be converted back to (x, y, yaw)\n"
+"#\n"
+"# Each joint is uniquely identified by its name\n"
+"# The header specifies the time at which the joint states were recorded. All the joint states\n"
+"# in one message have to be recorded at the same time.\n"
+"#\n"
+"# This message consists of a multiple arrays, one for each part of the joint state. \n"
+"# The goal is to make each of the fields optional. When e.g. your joints have no\n"
+"# wrench associated with them, you can leave the wrench array empty. \n"
+"#\n"
+"# All arrays in this message should have the same size, or be empty.\n"
+"# This is the only way to uniquely associate the joint name with the correct\n"
+"# states.\n"
+"\n"
+"Header header\n"
+"\n"
+"string[] joint_names\n"
+"geometry_msgs/Transform[] transforms\n"
+"geometry_msgs/Twist[] twist\n"
+"geometry_msgs/Wrench[] wrench\n"
+"\n"
+"================================================================================\n"
+"MSG: std_msgs/Header\n"
+"# Standard metadata for higher-level stamped data types.\n"
+"# This is generally used to communicate timestamped data \n"
+"# in a particular coordinate frame.\n"
+"# \n"
+"# sequence ID: consecutively increasing ID \n"
+"uint32 seq\n"
+"#Two-integer timestamp that is expressed as:\n"
+"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
+"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
+"# time-handling sugar is provided by the client library\n"
+"time stamp\n"
+"#Frame this data is associated with\n"
+"string frame_id\n"
+"\n"
+"================================================================================\n"
+"MSG: geometry_msgs/Transform\n"
+"# This represents the transform between two coordinate frames in free space.\n"
+"\n"
+"Vector3 translation\n"
+"Quaternion rotation\n"
+"\n"
+"================================================================================\n"
+"MSG: geometry_msgs/Vector3\n"
+"# This represents a vector in free space. \n"
+"# It is only meant to represent a direction. Therefore, it does not\n"
+"# make sense to apply a translation to it (e.g., when applying a \n"
+"# generic rigid transformation to a Vector3, tf2 will only apply the\n"
+"# rotation). If you want your data to be translatable too, use the\n"
+"# geometry_msgs/Point message instead.\n"
+"\n"
+"float64 x\n"
+"float64 y\n"
+"float64 z\n"
+"================================================================================\n"
+"MSG: geometry_msgs/Quaternion\n"
+"# This represents an orientation in free space in quaternion form.\n"
+"\n"
+"float64 x\n"
+"float64 y\n"
+"float64 z\n"
+"float64 w\n"
+"\n"
+"================================================================================\n"
+"MSG: geometry_msgs/Twist\n"
+"# This expresses velocity in free space broken into its linear and angular parts.\n"
+"Vector3  linear\n"
+"Vector3  angular\n"
+"\n"
+"================================================================================\n"
+"MSG: geometry_msgs/Wrench\n"
+"# This represents force in free space, separated into\n"
+"# its linear and angular parts.\n"
+"Vector3  force\n"
+"Vector3  torque\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::MultiDOFJointState_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.header);
+      stream.next(m.joint_names);
+      stream.next(m.transforms);
+      stream.next(m.twist);
+      stream.next(m.wrench);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct MultiDOFJointState_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::MultiDOFJointState_<ContainerAllocator>& v)
+  {
+    s << indent << "header: ";
+    s << std::endl;
+    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
+    s << indent << "joint_names[]" << std::endl;
+    for (size_t i = 0; i < v.joint_names.size(); ++i)
+    {
+      s << indent << "  joint_names[" << i << "]: ";
+      Printer<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>::stream(s, indent + "  ", v.joint_names[i]);
+    }
+    s << indent << "transforms[]" << std::endl;
+    for (size_t i = 0; i < v.transforms.size(); ++i)
+    {
+      s << indent << "  transforms[" << i << "]: ";
+      s << std::endl;
+      s << indent;
+      Printer< ::geometry_msgs::Transform_<ContainerAllocator> >::stream(s, indent + "    ", v.transforms[i]);
+    }
+    s << indent << "twist[]" << std::endl;
+    for (size_t i = 0; i < v.twist.size(); ++i)
+    {
+      s << indent << "  twist[" << i << "]: ";
+      s << std::endl;
+      s << indent;
+      Printer< ::geometry_msgs::Twist_<ContainerAllocator> >::stream(s, indent + "    ", v.twist[i]);
+    }
+    s << indent << "wrench[]" << std::endl;
+    for (size_t i = 0; i < v.wrench.size(); ++i)
+    {
+      s << indent << "  wrench[" << i << "]: ";
+      s << std::endl;
+      s << indent;
+      Printer< ::geometry_msgs::Wrench_<ContainerAllocator> >::stream(s, indent + "    ", v.wrench[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_MULTIDOFJOINTSTATE_H

thirdparty/ros/include/sensor_msgs/MultiEchoLaserScan.h

@@ -0,0 +1,345 @@
+// Generated by gencpp from file sensor_msgs/MultiEchoLaserScan.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_MULTIECHOLASERSCAN_H
+#define SENSOR_MSGS_MESSAGE_MULTIECHOLASERSCAN_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <std_msgs/Header.h>
+#include <sensor_msgs/LaserEcho.h>
+#include <sensor_msgs/LaserEcho.h>
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct MultiEchoLaserScan_
+{
+  typedef MultiEchoLaserScan_<ContainerAllocator> Type;
+
+  MultiEchoLaserScan_()
+    : header()
+    , angle_min(0.0)
+    , angle_max(0.0)
+    , angle_increment(0.0)
+    , time_increment(0.0)
+    , scan_time(0.0)
+    , range_min(0.0)
+    , range_max(0.0)
+    , ranges()
+    , intensities()  {
+    }
+  MultiEchoLaserScan_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , angle_min(0.0)
+    , angle_max(0.0)
+    , angle_increment(0.0)
+    , time_increment(0.0)
+    , scan_time(0.0)
+    , range_min(0.0)
+    , range_max(0.0)
+    , ranges(_alloc)
+    , intensities(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
+  _header_type header;
+
+   typedef float _angle_min_type;
+  _angle_min_type angle_min;
+
+   typedef float _angle_max_type;
+  _angle_max_type angle_max;
+
+   typedef float _angle_increment_type;
+  _angle_increment_type angle_increment;
+
+   typedef float _time_increment_type;
+  _time_increment_type time_increment;
+
+   typedef float _scan_time_type;
+  _scan_time_type scan_time;
+
+   typedef float _range_min_type;
+  _range_min_type range_min;
+
+   typedef float _range_max_type;
+  _range_max_type range_max;
+
+   typedef std::vector< ::sensor_msgs::LaserEcho_<ContainerAllocator> , typename std::allocator_traits<ContainerAllocator>::template rebind_alloc< ::sensor_msgs::LaserEcho_<ContainerAllocator> >> _ranges_type;
+  _ranges_type ranges;
+
+   typedef std::vector< ::sensor_msgs::LaserEcho_<ContainerAllocator> , typename std::allocator_traits<ContainerAllocator>::template rebind_alloc< ::sensor_msgs::LaserEcho_<ContainerAllocator> >> _intensities_type;
+  _intensities_type intensities;
+
+
+
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> const> ConstPtr;
+
+}; // struct MultiEchoLaserScan_
+
+typedef ::sensor_msgs::MultiEchoLaserScan_<std::allocator<void> > MultiEchoLaserScan;
+
+typedef boost::shared_ptr< ::sensor_msgs::MultiEchoLaserScan > MultiEchoLaserScanPtr;
+typedef boost::shared_ptr< ::sensor_msgs::MultiEchoLaserScan const> MultiEchoLaserScanConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator1> & lhs, const ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.angle_min == rhs.angle_min &&
+    lhs.angle_max == rhs.angle_max &&
+    lhs.angle_increment == rhs.angle_increment &&
+    lhs.time_increment == rhs.time_increment &&
+    lhs.scan_time == rhs.scan_time &&
+    lhs.range_min == rhs.range_min &&
+    lhs.range_max == rhs.range_max &&
+    lhs.ranges == rhs.ranges &&
+    lhs.intensities == rhs.intensities;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator1> & lhs, const ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "6fefb0c6da89d7c8abe4b339f5c2f8fb";
+  }
+
+  static const char* value(const ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x6fefb0c6da89d7c8ULL;
+  static const uint64_t static_value2 = 0xabe4b339f5c2f8fbULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/MultiEchoLaserScan";
+  }
+
+  static const char* value(const ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# Single scan from a multi-echo planar laser range-finder\n"
+"#\n"
+"# If you have another ranging device with different behavior (e.g. a sonar\n"
+"# array), please find or create a different message, since applications\n"
+"# will make fairly laser-specific assumptions about this data\n"
+"\n"
+"Header header            # timestamp in the header is the acquisition time of \n"
+"                         # the first ray in the scan.\n"
+"                         #\n"
+"                         # in frame frame_id, angles are measured around \n"
+"                         # the positive Z axis (counterclockwise, if Z is up)\n"
+"                         # with zero angle being forward along the x axis\n"
+"                         \n"
+"float32 angle_min        # start angle of the scan [rad]\n"
+"float32 angle_max        # end angle of the scan [rad]\n"
+"float32 angle_increment  # angular distance between measurements [rad]\n"
+"\n"
+"float32 time_increment   # time between measurements [seconds] - if your scanner\n"
+"                         # is moving, this will be used in interpolating position\n"
+"                         # of 3d points\n"
+"float32 scan_time        # time between scans [seconds]\n"
+"\n"
+"float32 range_min        # minimum range value [m]\n"
+"float32 range_max        # maximum range value [m]\n"
+"\n"
+"LaserEcho[] ranges       # range data [m] (Note: NaNs, values < range_min or > range_max should be discarded)\n"
+"                         # +Inf measurements are out of range\n"
+"                         # -Inf measurements are too close to determine exact distance.\n"
+"LaserEcho[] intensities  # intensity data [device-specific units].  If your\n"
+"                         # device does not provide intensities, please leave\n"
+"                         # the array empty.\n"
+"================================================================================\n"
+"MSG: std_msgs/Header\n"
+"# Standard metadata for higher-level stamped data types.\n"
+"# This is generally used to communicate timestamped data \n"
+"# in a particular coordinate frame.\n"
+"# \n"
+"# sequence ID: consecutively increasing ID \n"
+"uint32 seq\n"
+"#Two-integer timestamp that is expressed as:\n"
+"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
+"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
+"# time-handling sugar is provided by the client library\n"
+"time stamp\n"
+"#Frame this data is associated with\n"
+"string frame_id\n"
+"\n"
+"================================================================================\n"
+"MSG: sensor_msgs/LaserEcho\n"
+"# This message is a submessage of MultiEchoLaserScan and is not intended\n"
+"# to be used separately.\n"
+"\n"
+"float32[] echoes  # Multiple values of ranges or intensities.\n"
+"                  # Each array represents data from the same angle increment.\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.header);
+      stream.next(m.angle_min);
+      stream.next(m.angle_max);
+      stream.next(m.angle_increment);
+      stream.next(m.time_increment);
+      stream.next(m.scan_time);
+      stream.next(m.range_min);
+      stream.next(m.range_max);
+      stream.next(m.ranges);
+      stream.next(m.intensities);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct MultiEchoLaserScan_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator>& v)
+  {
+    s << indent << "header: ";
+    s << std::endl;
+    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
+    s << indent << "angle_min: ";
+    Printer<float>::stream(s, indent + "  ", v.angle_min);
+    s << indent << "angle_max: ";
+    Printer<float>::stream(s, indent + "  ", v.angle_max);
+    s << indent << "angle_increment: ";
+    Printer<float>::stream(s, indent + "  ", v.angle_increment);
+    s << indent << "time_increment: ";
+    Printer<float>::stream(s, indent + "  ", v.time_increment);
+    s << indent << "scan_time: ";
+    Printer<float>::stream(s, indent + "  ", v.scan_time);
+    s << indent << "range_min: ";
+    Printer<float>::stream(s, indent + "  ", v.range_min);
+    s << indent << "range_max: ";
+    Printer<float>::stream(s, indent + "  ", v.range_max);
+    s << indent << "ranges[]" << std::endl;
+    for (size_t i = 0; i < v.ranges.size(); ++i)
+    {
+      s << indent << "  ranges[" << i << "]: ";
+      s << std::endl;
+      s << indent;
+      Printer< ::sensor_msgs::LaserEcho_<ContainerAllocator> >::stream(s, indent + "    ", v.ranges[i]);
+    }
+    s << indent << "intensities[]" << std::endl;
+    for (size_t i = 0; i < v.intensities.size(); ++i)
+    {
+      s << indent << "  intensities[" << i << "]: ";
+      s << std::endl;
+      s << indent;
+      Printer< ::sensor_msgs::LaserEcho_<ContainerAllocator> >::stream(s, indent + "    ", v.intensities[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_MULTIECHOLASERSCAN_H

thirdparty/ros/include/sensor_msgs/NavSatFix.h

@@ -0,0 +1,373 @@
+// Generated by gencpp from file sensor_msgs/NavSatFix.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_NAVSATFIX_H
+#define SENSOR_MSGS_MESSAGE_NAVSATFIX_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <std_msgs/Header.h>
+#include <sensor_msgs/NavSatStatus.h>
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct NavSatFix_
+{
+  typedef NavSatFix_<ContainerAllocator> Type;
+
+  NavSatFix_()
+    : header()
+    , status()
+    , latitude(0.0)
+    , longitude(0.0)
+    , altitude(0.0)
+    , position_covariance()
+    , position_covariance_type(0)  {
+      position_covariance.assign(0.0);
+  }
+  NavSatFix_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , status(_alloc)
+    , latitude(0.0)
+    , longitude(0.0)
+    , altitude(0.0)
+    , position_covariance()
+    , position_covariance_type(0)  {
+  (void)_alloc;
+      position_covariance.assign(0.0);
+  }
+
+
+
+   typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
+  _header_type header;
+
+   typedef  ::sensor_msgs::NavSatStatus_<ContainerAllocator>  _status_type;
+  _status_type status;
+
+   typedef double _latitude_type;
+  _latitude_type latitude;
+
+   typedef double _longitude_type;
+  _longitude_type longitude;
+
+   typedef double _altitude_type;
+  _altitude_type altitude;
+
+   typedef boost::array<double, 9>  _position_covariance_type;
+  _position_covariance_type position_covariance;
+
+   typedef uint8_t _position_covariance_type_type;
+  _position_covariance_type_type position_covariance_type;
+
+
+
+// reducing the odds to have name collisions with Windows.h 
+#if defined(_WIN32) && defined(COVARIANCE_TYPE_UNKNOWN)
+  #undef COVARIANCE_TYPE_UNKNOWN
+#endif
+#if defined(_WIN32) && defined(COVARIANCE_TYPE_APPROXIMATED)
+  #undef COVARIANCE_TYPE_APPROXIMATED
+#endif
+#if defined(_WIN32) && defined(COVARIANCE_TYPE_DIAGONAL_KNOWN)
+  #undef COVARIANCE_TYPE_DIAGONAL_KNOWN
+#endif
+#if defined(_WIN32) && defined(COVARIANCE_TYPE_KNOWN)
+  #undef COVARIANCE_TYPE_KNOWN
+#endif
+
+  enum {
+    COVARIANCE_TYPE_UNKNOWN = 0u,
+    COVARIANCE_TYPE_APPROXIMATED = 1u,
+    COVARIANCE_TYPE_DIAGONAL_KNOWN = 2u,
+    COVARIANCE_TYPE_KNOWN = 3u,
+  };
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::NavSatFix_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::NavSatFix_<ContainerAllocator> const> ConstPtr;
+
+}; // struct NavSatFix_
+
+typedef ::sensor_msgs::NavSatFix_<std::allocator<void> > NavSatFix;
+
+typedef boost::shared_ptr< ::sensor_msgs::NavSatFix > NavSatFixPtr;
+typedef boost::shared_ptr< ::sensor_msgs::NavSatFix const> NavSatFixConstPtr;
+
+// constants requiring out of line definition
+
+   
+
+   
+
+   
+
+   
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::NavSatFix_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::NavSatFix_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::NavSatFix_<ContainerAllocator1> & lhs, const ::sensor_msgs::NavSatFix_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.status == rhs.status &&
+    lhs.latitude == rhs.latitude &&
+    lhs.longitude == rhs.longitude &&
+    lhs.altitude == rhs.altitude &&
+    lhs.position_covariance == rhs.position_covariance &&
+    lhs.position_covariance_type == rhs.position_covariance_type;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::NavSatFix_<ContainerAllocator1> & lhs, const ::sensor_msgs::NavSatFix_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::NavSatFix_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::NavSatFix_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::NavSatFix_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::NavSatFix_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::NavSatFix_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::NavSatFix_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::NavSatFix_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "2d3a8cd499b9b4a0249fb98fd05cfa48";
+  }
+
+  static const char* value(const ::sensor_msgs::NavSatFix_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x2d3a8cd499b9b4a0ULL;
+  static const uint64_t static_value2 = 0x249fb98fd05cfa48ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::NavSatFix_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/NavSatFix";
+  }
+
+  static const char* value(const ::sensor_msgs::NavSatFix_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::NavSatFix_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# Navigation Satellite fix for any Global Navigation Satellite System\n"
+"#\n"
+"# Specified using the WGS 84 reference ellipsoid\n"
+"\n"
+"# header.stamp specifies the ROS time for this measurement (the\n"
+"#        corresponding satellite time may be reported using the\n"
+"#        sensor_msgs/TimeReference message).\n"
+"#\n"
+"# header.frame_id is the frame of reference reported by the satellite\n"
+"#        receiver, usually the location of the antenna.  This is a\n"
+"#        Euclidean frame relative to the vehicle, not a reference\n"
+"#        ellipsoid.\n"
+"Header header\n"
+"\n"
+"# satellite fix status information\n"
+"NavSatStatus status\n"
+"\n"
+"# Latitude [degrees]. Positive is north of equator; negative is south.\n"
+"float64 latitude\n"
+"\n"
+"# Longitude [degrees]. Positive is east of prime meridian; negative is west.\n"
+"float64 longitude\n"
+"\n"
+"# Altitude [m]. Positive is above the WGS 84 ellipsoid\n"
+"# (quiet NaN if no altitude is available).\n"
+"float64 altitude\n"
+"\n"
+"# Position covariance [m^2] defined relative to a tangential plane\n"
+"# through the reported position. The components are East, North, and\n"
+"# Up (ENU), in row-major order.\n"
+"#\n"
+"# Beware: this coordinate system exhibits singularities at the poles.\n"
+"\n"
+"float64[9] position_covariance\n"
+"\n"
+"# If the covariance of the fix is known, fill it in completely. If the\n"
+"# GPS receiver provides the variance of each measurement, put them\n"
+"# along the diagonal. If only Dilution of Precision is available,\n"
+"# estimate an approximate covariance from that.\n"
+"\n"
+"uint8 COVARIANCE_TYPE_UNKNOWN = 0\n"
+"uint8 COVARIANCE_TYPE_APPROXIMATED = 1\n"
+"uint8 COVARIANCE_TYPE_DIAGONAL_KNOWN = 2\n"
+"uint8 COVARIANCE_TYPE_KNOWN = 3\n"
+"\n"
+"uint8 position_covariance_type\n"
+"\n"
+"================================================================================\n"
+"MSG: std_msgs/Header\n"
+"# Standard metadata for higher-level stamped data types.\n"
+"# This is generally used to communicate timestamped data \n"
+"# in a particular coordinate frame.\n"
+"# \n"
+"# sequence ID: consecutively increasing ID \n"
+"uint32 seq\n"
+"#Two-integer timestamp that is expressed as:\n"
+"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
+"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
+"# time-handling sugar is provided by the client library\n"
+"time stamp\n"
+"#Frame this data is associated with\n"
+"string frame_id\n"
+"\n"
+"================================================================================\n"
+"MSG: sensor_msgs/NavSatStatus\n"
+"# Navigation Satellite fix status for any Global Navigation Satellite System\n"
+"\n"
+"# Whether to output an augmented fix is determined by both the fix\n"
+"# type and the last time differential corrections were received.  A\n"
+"# fix is valid when status >= STATUS_FIX.\n"
+"\n"
+"int8 STATUS_NO_FIX =  -1        # unable to fix position\n"
+"int8 STATUS_FIX =      0        # unaugmented fix\n"
+"int8 STATUS_SBAS_FIX = 1        # with satellite-based augmentation\n"
+"int8 STATUS_GBAS_FIX = 2        # with ground-based augmentation\n"
+"\n"
+"int8 status\n"
+"\n"
+"# Bits defining which Global Navigation Satellite System signals were\n"
+"# used by the receiver.\n"
+"\n"
+"uint16 SERVICE_GPS =     1\n"
+"uint16 SERVICE_GLONASS = 2\n"
+"uint16 SERVICE_COMPASS = 4      # includes BeiDou.\n"
+"uint16 SERVICE_GALILEO = 8\n"
+"\n"
+"uint16 service\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::NavSatFix_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::NavSatFix_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.header);
+      stream.next(m.status);
+      stream.next(m.latitude);
+      stream.next(m.longitude);
+      stream.next(m.altitude);
+      stream.next(m.position_covariance);
+      stream.next(m.position_covariance_type);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct NavSatFix_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::NavSatFix_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::NavSatFix_<ContainerAllocator>& v)
+  {
+    s << indent << "header: ";
+    s << std::endl;
+    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
+    s << indent << "status: ";
+    s << std::endl;
+    Printer< ::sensor_msgs::NavSatStatus_<ContainerAllocator> >::stream(s, indent + "  ", v.status);
+    s << indent << "latitude: ";
+    Printer<double>::stream(s, indent + "  ", v.latitude);
+    s << indent << "longitude: ";
+    Printer<double>::stream(s, indent + "  ", v.longitude);
+    s << indent << "altitude: ";
+    Printer<double>::stream(s, indent + "  ", v.altitude);
+    s << indent << "position_covariance[]" << std::endl;
+    for (size_t i = 0; i < v.position_covariance.size(); ++i)
+    {
+      s << indent << "  position_covariance[" << i << "]: ";
+      Printer<double>::stream(s, indent + "  ", v.position_covariance[i]);
+    }
+    s << indent << "position_covariance_type: ";
+    Printer<uint8_t>::stream(s, indent + "  ", v.position_covariance_type);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_NAVSATFIX_H

thirdparty/ros/include/sensor_msgs/NavSatStatus.h

@@ -0,0 +1,277 @@
+// Generated by gencpp from file sensor_msgs/NavSatStatus.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_NAVSATSTATUS_H
+#define SENSOR_MSGS_MESSAGE_NAVSATSTATUS_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct NavSatStatus_
+{
+  typedef NavSatStatus_<ContainerAllocator> Type;
+
+  NavSatStatus_()
+    : status(0)
+    , service(0)  {
+    }
+  NavSatStatus_(const ContainerAllocator& _alloc)
+    : status(0)
+    , service(0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef int8_t _status_type;
+  _status_type status;
+
+   typedef uint16_t _service_type;
+  _service_type service;
+
+
+
+// reducing the odds to have name collisions with Windows.h 
+#if defined(_WIN32) && defined(STATUS_NO_FIX)
+  #undef STATUS_NO_FIX
+#endif
+#if defined(_WIN32) && defined(STATUS_FIX)
+  #undef STATUS_FIX
+#endif
+#if defined(_WIN32) && defined(STATUS_SBAS_FIX)
+  #undef STATUS_SBAS_FIX
+#endif
+#if defined(_WIN32) && defined(STATUS_GBAS_FIX)
+  #undef STATUS_GBAS_FIX
+#endif
+#if defined(_WIN32) && defined(SERVICE_GPS)
+  #undef SERVICE_GPS
+#endif
+#if defined(_WIN32) && defined(SERVICE_GLONASS)
+  #undef SERVICE_GLONASS
+#endif
+#if defined(_WIN32) && defined(SERVICE_COMPASS)
+  #undef SERVICE_COMPASS
+#endif
+#if defined(_WIN32) && defined(SERVICE_GALILEO)
+  #undef SERVICE_GALILEO
+#endif
+
+  enum {
+    STATUS_NO_FIX = -1,
+    STATUS_FIX = 0,
+    STATUS_SBAS_FIX = 1,
+    STATUS_GBAS_FIX = 2,
+    SERVICE_GPS = 1u,
+    SERVICE_GLONASS = 2u,
+    SERVICE_COMPASS = 4u,
+    SERVICE_GALILEO = 8u,
+  };
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::NavSatStatus_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::NavSatStatus_<ContainerAllocator> const> ConstPtr;
+
+}; // struct NavSatStatus_
+
+typedef ::sensor_msgs::NavSatStatus_<std::allocator<void> > NavSatStatus;
+
+typedef boost::shared_ptr< ::sensor_msgs::NavSatStatus > NavSatStatusPtr;
+typedef boost::shared_ptr< ::sensor_msgs::NavSatStatus const> NavSatStatusConstPtr;
+
+// constants requiring out of line definition
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::NavSatStatus_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::NavSatStatus_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::NavSatStatus_<ContainerAllocator1> & lhs, const ::sensor_msgs::NavSatStatus_<ContainerAllocator2> & rhs)
+{
+  return lhs.status == rhs.status &&
+    lhs.service == rhs.service;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::NavSatStatus_<ContainerAllocator1> & lhs, const ::sensor_msgs::NavSatStatus_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::NavSatStatus_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::NavSatStatus_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::NavSatStatus_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::NavSatStatus_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::NavSatStatus_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::NavSatStatus_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::NavSatStatus_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "331cdbddfa4bc96ffc3b9ad98900a54c";
+  }
+
+  static const char* value(const ::sensor_msgs::NavSatStatus_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x331cdbddfa4bc96fULL;
+  static const uint64_t static_value2 = 0xfc3b9ad98900a54cULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::NavSatStatus_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/NavSatStatus";
+  }
+
+  static const char* value(const ::sensor_msgs::NavSatStatus_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::NavSatStatus_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# Navigation Satellite fix status for any Global Navigation Satellite System\n"
+"\n"
+"# Whether to output an augmented fix is determined by both the fix\n"
+"# type and the last time differential corrections were received.  A\n"
+"# fix is valid when status >= STATUS_FIX.\n"
+"\n"
+"int8 STATUS_NO_FIX =  -1        # unable to fix position\n"
+"int8 STATUS_FIX =      0        # unaugmented fix\n"
+"int8 STATUS_SBAS_FIX = 1        # with satellite-based augmentation\n"
+"int8 STATUS_GBAS_FIX = 2        # with ground-based augmentation\n"
+"\n"
+"int8 status\n"
+"\n"
+"# Bits defining which Global Navigation Satellite System signals were\n"
+"# used by the receiver.\n"
+"\n"
+"uint16 SERVICE_GPS =     1\n"
+"uint16 SERVICE_GLONASS = 2\n"
+"uint16 SERVICE_COMPASS = 4      # includes BeiDou.\n"
+"uint16 SERVICE_GALILEO = 8\n"
+"\n"
+"uint16 service\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::NavSatStatus_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::NavSatStatus_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.status);
+      stream.next(m.service);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct NavSatStatus_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::NavSatStatus_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::NavSatStatus_<ContainerAllocator>& v)
+  {
+    s << indent << "status: ";
+    Printer<int8_t>::stream(s, indent + "  ", v.status);
+    s << indent << "service: ";
+    Printer<uint16_t>::stream(s, indent + "  ", v.service);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_NAVSATSTATUS_H

thirdparty/ros/include/sensor_msgs/PointCloud.h

@@ -0,0 +1,298 @@
+// Generated by gencpp from file sensor_msgs/PointCloud.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_POINTCLOUD_H
+#define SENSOR_MSGS_MESSAGE_POINTCLOUD_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <std_msgs/Header.h>
+#include <geometry_msgs/Point32.h>
+#include <sensor_msgs/ChannelFloat32.h>
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct PointCloud_
+{
+  typedef PointCloud_<ContainerAllocator> Type;
+
+  PointCloud_()
+    : header()
+    , points()
+    , channels()  {
+    }
+  PointCloud_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , points(_alloc)
+    , channels(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
+  _header_type header;
+
+   typedef std::vector< ::geometry_msgs::Point32_<ContainerAllocator> , typename std::allocator_traits<ContainerAllocator>::template rebind_alloc< ::geometry_msgs::Point32_<ContainerAllocator> >> _points_type;
+  _points_type points;
+
+   typedef std::vector< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> , typename std::allocator_traits<ContainerAllocator>::template rebind_alloc< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> >> _channels_type;
+  _channels_type channels;
+
+
+
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::PointCloud_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::PointCloud_<ContainerAllocator> const> ConstPtr;
+
+}; // struct PointCloud_
+
+typedef ::sensor_msgs::PointCloud_<std::allocator<void> > PointCloud;
+
+typedef boost::shared_ptr< ::sensor_msgs::PointCloud > PointCloudPtr;
+typedef boost::shared_ptr< ::sensor_msgs::PointCloud const> PointCloudConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::PointCloud_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::PointCloud_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::PointCloud_<ContainerAllocator1> & lhs, const ::sensor_msgs::PointCloud_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.points == rhs.points &&
+    lhs.channels == rhs.channels;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::PointCloud_<ContainerAllocator1> & lhs, const ::sensor_msgs::PointCloud_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::PointCloud_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::PointCloud_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::PointCloud_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::PointCloud_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::PointCloud_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::PointCloud_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::PointCloud_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "d8e9c3f5afbdd8a130fd1d2763945fca";
+  }
+
+  static const char* value(const ::sensor_msgs::PointCloud_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0xd8e9c3f5afbdd8a1ULL;
+  static const uint64_t static_value2 = 0x30fd1d2763945fcaULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::PointCloud_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/PointCloud";
+  }
+
+  static const char* value(const ::sensor_msgs::PointCloud_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::PointCloud_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# This message holds a collection of 3d points, plus optional additional\n"
+"# information about each point.\n"
+"\n"
+"# Time of sensor data acquisition, coordinate frame ID.\n"
+"Header header\n"
+"\n"
+"# Array of 3d points. Each Point32 should be interpreted as a 3d point\n"
+"# in the frame given in the header.\n"
+"geometry_msgs/Point32[] points\n"
+"\n"
+"# Each channel should have the same number of elements as points array,\n"
+"# and the data in each channel should correspond 1:1 with each point.\n"
+"# Channel names in common practice are listed in ChannelFloat32.msg.\n"
+"ChannelFloat32[] channels\n"
+"\n"
+"================================================================================\n"
+"MSG: std_msgs/Header\n"
+"# Standard metadata for higher-level stamped data types.\n"
+"# This is generally used to communicate timestamped data \n"
+"# in a particular coordinate frame.\n"
+"# \n"
+"# sequence ID: consecutively increasing ID \n"
+"uint32 seq\n"
+"#Two-integer timestamp that is expressed as:\n"
+"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
+"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
+"# time-handling sugar is provided by the client library\n"
+"time stamp\n"
+"#Frame this data is associated with\n"
+"string frame_id\n"
+"\n"
+"================================================================================\n"
+"MSG: geometry_msgs/Point32\n"
+"# This contains the position of a point in free space(with 32 bits of precision).\n"
+"# It is recommeded to use Point wherever possible instead of Point32.  \n"
+"# \n"
+"# This recommendation is to promote interoperability.  \n"
+"#\n"
+"# This message is designed to take up less space when sending\n"
+"# lots of points at once, as in the case of a PointCloud.  \n"
+"\n"
+"float32 x\n"
+"float32 y\n"
+"float32 z\n"
+"================================================================================\n"
+"MSG: sensor_msgs/ChannelFloat32\n"
+"# This message is used by the PointCloud message to hold optional data\n"
+"# associated with each point in the cloud. The length of the values\n"
+"# array should be the same as the length of the points array in the\n"
+"# PointCloud, and each value should be associated with the corresponding\n"
+"# point.\n"
+"\n"
+"# Channel names in existing practice include:\n"
+"#   \"u\", \"v\" - row and column (respectively) in the left stereo image.\n"
+"#              This is opposite to usual conventions but remains for\n"
+"#              historical reasons. The newer PointCloud2 message has no\n"
+"#              such problem.\n"
+"#   \"rgb\" - For point clouds produced by color stereo cameras. uint8\n"
+"#           (R,G,B) values packed into the least significant 24 bits,\n"
+"#           in order.\n"
+"#   \"intensity\" - laser or pixel intensity.\n"
+"#   \"distance\"\n"
+"\n"
+"# The channel name should give semantics of the channel (e.g.\n"
+"# \"intensity\" instead of \"value\").\n"
+"string name\n"
+"\n"
+"# The values array should be 1-1 with the elements of the associated\n"
+"# PointCloud.\n"
+"float32[] values\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::PointCloud_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::PointCloud_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.header);
+      stream.next(m.points);
+      stream.next(m.channels);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct PointCloud_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::PointCloud_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::PointCloud_<ContainerAllocator>& v)
+  {
+    s << indent << "header: ";
+    s << std::endl;
+    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
+    s << indent << "points[]" << std::endl;
+    for (size_t i = 0; i < v.points.size(); ++i)
+    {
+      s << indent << "  points[" << i << "]: ";
+      s << std::endl;
+      s << indent;
+      Printer< ::geometry_msgs::Point32_<ContainerAllocator> >::stream(s, indent + "    ", v.points[i]);
+    }
+    s << indent << "channels[]" << std::endl;
+    for (size_t i = 0; i < v.channels.size(); ++i)
+    {
+      s << indent << "  channels[" << i << "]: ";
+      s << std::endl;
+      s << indent;
+      Printer< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> >::stream(s, indent + "    ", v.channels[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_POINTCLOUD_H

thirdparty/ros/include/sensor_msgs/PointCloud2.h

@@ -0,0 +1,340 @@
+// Generated by gencpp from file sensor_msgs/PointCloud2.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_POINTCLOUD2_H
+#define SENSOR_MSGS_MESSAGE_POINTCLOUD2_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <std_msgs/Header.h>
+#include <sensor_msgs/PointField.h>
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct PointCloud2_
+{
+  typedef PointCloud2_<ContainerAllocator> Type;
+
+  PointCloud2_()
+    : header()
+    , height(0)
+    , width(0)
+    , fields()
+    , is_bigendian(false)
+    , point_step(0)
+    , row_step(0)
+    , data()
+    , is_dense(false)  {
+    }
+  PointCloud2_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , height(0)
+    , width(0)
+    , fields(_alloc)
+    , is_bigendian(false)
+    , point_step(0)
+    , row_step(0)
+    , data(_alloc)
+    , is_dense(false)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
+  _header_type header;
+
+   typedef uint32_t _height_type;
+  _height_type height;
+
+   typedef uint32_t _width_type;
+  _width_type width;
+
+   typedef std::vector< ::sensor_msgs::PointField_<ContainerAllocator> , typename std::allocator_traits<ContainerAllocator>::template rebind_alloc< ::sensor_msgs::PointField_<ContainerAllocator> >> _fields_type;
+  _fields_type fields;
+
+   typedef uint8_t _is_bigendian_type;
+  _is_bigendian_type is_bigendian;
+
+   typedef uint32_t _point_step_type;
+  _point_step_type point_step;
+
+   typedef uint32_t _row_step_type;
+  _row_step_type row_step;
+
+   typedef std::vector<uint8_t, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<uint8_t>> _data_type;
+  _data_type data;
+
+   typedef uint8_t _is_dense_type;
+  _is_dense_type is_dense;
+
+
+
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::PointCloud2_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::PointCloud2_<ContainerAllocator> const> ConstPtr;
+
+}; // struct PointCloud2_
+
+typedef ::sensor_msgs::PointCloud2_<std::allocator<void> > PointCloud2;
+
+typedef boost::shared_ptr< ::sensor_msgs::PointCloud2 > PointCloud2Ptr;
+typedef boost::shared_ptr< ::sensor_msgs::PointCloud2 const> PointCloud2ConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::PointCloud2_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::PointCloud2_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::PointCloud2_<ContainerAllocator1> & lhs, const ::sensor_msgs::PointCloud2_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.height == rhs.height &&
+    lhs.width == rhs.width &&
+    lhs.fields == rhs.fields &&
+    lhs.is_bigendian == rhs.is_bigendian &&
+    lhs.point_step == rhs.point_step &&
+    lhs.row_step == rhs.row_step &&
+    lhs.data == rhs.data &&
+    lhs.is_dense == rhs.is_dense;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::PointCloud2_<ContainerAllocator1> & lhs, const ::sensor_msgs::PointCloud2_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::PointCloud2_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::PointCloud2_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::PointCloud2_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::PointCloud2_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::PointCloud2_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::PointCloud2_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::PointCloud2_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "1158d486dd51d683ce2f1be655c3c181";
+  }
+
+  static const char* value(const ::sensor_msgs::PointCloud2_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x1158d486dd51d683ULL;
+  static const uint64_t static_value2 = 0xce2f1be655c3c181ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::PointCloud2_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/PointCloud2";
+  }
+
+  static const char* value(const ::sensor_msgs::PointCloud2_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::PointCloud2_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# This message holds a collection of N-dimensional points, which may\n"
+"# contain additional information such as normals, intensity, etc. The\n"
+"# point data is stored as a binary blob, its layout described by the\n"
+"# contents of the \"fields\" array.\n"
+"\n"
+"# The point cloud data may be organized 2d (image-like) or 1d\n"
+"# (unordered). Point clouds organized as 2d images may be produced by\n"
+"# camera depth sensors such as stereo or time-of-flight.\n"
+"\n"
+"# Time of sensor data acquisition, and the coordinate frame ID (for 3d\n"
+"# points).\n"
+"Header header\n"
+"\n"
+"# 2D structure of the point cloud. If the cloud is unordered, height is\n"
+"# 1 and width is the length of the point cloud.\n"
+"uint32 height\n"
+"uint32 width\n"
+"\n"
+"# Describes the channels and their layout in the binary data blob.\n"
+"PointField[] fields\n"
+"\n"
+"bool    is_bigendian # Is this data bigendian?\n"
+"uint32  point_step   # Length of a point in bytes\n"
+"uint32  row_step     # Length of a row in bytes\n"
+"uint8[] data         # Actual point data, size is (row_step*height)\n"
+"\n"
+"bool is_dense        # True if there are no invalid points\n"
+"\n"
+"================================================================================\n"
+"MSG: std_msgs/Header\n"
+"# Standard metadata for higher-level stamped data types.\n"
+"# This is generally used to communicate timestamped data \n"
+"# in a particular coordinate frame.\n"
+"# \n"
+"# sequence ID: consecutively increasing ID \n"
+"uint32 seq\n"
+"#Two-integer timestamp that is expressed as:\n"
+"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
+"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
+"# time-handling sugar is provided by the client library\n"
+"time stamp\n"
+"#Frame this data is associated with\n"
+"string frame_id\n"
+"\n"
+"================================================================================\n"
+"MSG: sensor_msgs/PointField\n"
+"# This message holds the description of one point entry in the\n"
+"# PointCloud2 message format.\n"
+"uint8 INT8    = 1\n"
+"uint8 UINT8   = 2\n"
+"uint8 INT16   = 3\n"
+"uint8 UINT16  = 4\n"
+"uint8 INT32   = 5\n"
+"uint8 UINT32  = 6\n"
+"uint8 FLOAT32 = 7\n"
+"uint8 FLOAT64 = 8\n"
+"\n"
+"string name      # Name of field\n"
+"uint32 offset    # Offset from start of point struct\n"
+"uint8  datatype  # Datatype enumeration, see above\n"
+"uint32 count     # How many elements in the field\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::PointCloud2_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::PointCloud2_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.header);
+      stream.next(m.height);
+      stream.next(m.width);
+      stream.next(m.fields);
+      stream.next(m.is_bigendian);
+      stream.next(m.point_step);
+      stream.next(m.row_step);
+      stream.next(m.data);
+      stream.next(m.is_dense);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct PointCloud2_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::PointCloud2_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::PointCloud2_<ContainerAllocator>& v)
+  {
+    s << indent << "header: ";
+    s << std::endl;
+    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
+    s << indent << "height: ";
+    Printer<uint32_t>::stream(s, indent + "  ", v.height);
+    s << indent << "width: ";
+    Printer<uint32_t>::stream(s, indent + "  ", v.width);
+    s << indent << "fields[]" << std::endl;
+    for (size_t i = 0; i < v.fields.size(); ++i)
+    {
+      s << indent << "  fields[" << i << "]: ";
+      s << std::endl;
+      s << indent;
+      Printer< ::sensor_msgs::PointField_<ContainerAllocator> >::stream(s, indent + "    ", v.fields[i]);
+    }
+    s << indent << "is_bigendian: ";
+    Printer<uint8_t>::stream(s, indent + "  ", v.is_bigendian);
+    s << indent << "point_step: ";
+    Printer<uint32_t>::stream(s, indent + "  ", v.point_step);
+    s << indent << "row_step: ";
+    Printer<uint32_t>::stream(s, indent + "  ", v.row_step);
+    s << indent << "data[]" << std::endl;
+    for (size_t i = 0; i < v.data.size(); ++i)
+    {
+      s << indent << "  data[" << i << "]: ";
+      Printer<uint8_t>::stream(s, indent + "  ", v.data[i]);
+    }
+    s << indent << "is_dense: ";
+    Printer<uint8_t>::stream(s, indent + "  ", v.is_dense);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_POINTCLOUD2_H

thirdparty/ros/include/sensor_msgs/PointField.h

@@ -0,0 +1,288 @@
+// Generated by gencpp from file sensor_msgs/PointField.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_POINTFIELD_H
+#define SENSOR_MSGS_MESSAGE_POINTFIELD_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct PointField_
+{
+  typedef PointField_<ContainerAllocator> Type;
+
+  PointField_()
+    : name()
+    , offset(0)
+    , datatype(0)
+    , count(0)  {
+    }
+  PointField_(const ContainerAllocator& _alloc)
+    : name(_alloc)
+    , offset(0)
+    , datatype(0)
+    , count(0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _name_type;
+  _name_type name;
+
+   typedef uint32_t _offset_type;
+  _offset_type offset;
+
+   typedef uint8_t _datatype_type;
+  _datatype_type datatype;
+
+   typedef uint32_t _count_type;
+  _count_type count;
+
+
+
+// reducing the odds to have name collisions with Windows.h 
+#if defined(_WIN32) && defined(INT8)
+  #undef INT8
+#endif
+#if defined(_WIN32) && defined(UINT8)
+  #undef UINT8
+#endif
+#if defined(_WIN32) && defined(INT16)
+  #undef INT16
+#endif
+#if defined(_WIN32) && defined(UINT16)
+  #undef UINT16
+#endif
+#if defined(_WIN32) && defined(INT32)
+  #undef INT32
+#endif
+#if defined(_WIN32) && defined(UINT32)
+  #undef UINT32
+#endif
+#if defined(_WIN32) && defined(FLOAT32)
+  #undef FLOAT32
+#endif
+#if defined(_WIN32) && defined(FLOAT64)
+  #undef FLOAT64
+#endif
+
+  enum {
+    INT8 = 1u,
+    UINT8 = 2u,
+    INT16 = 3u,
+    UINT16 = 4u,
+    INT32 = 5u,
+    UINT32 = 6u,
+    FLOAT32 = 7u,
+    FLOAT64 = 8u,
+  };
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::PointField_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::PointField_<ContainerAllocator> const> ConstPtr;
+
+}; // struct PointField_
+
+typedef ::sensor_msgs::PointField_<std::allocator<void> > PointField;
+
+typedef boost::shared_ptr< ::sensor_msgs::PointField > PointFieldPtr;
+typedef boost::shared_ptr< ::sensor_msgs::PointField const> PointFieldConstPtr;
+
+// constants requiring out of line definition
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::PointField_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::PointField_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::PointField_<ContainerAllocator1> & lhs, const ::sensor_msgs::PointField_<ContainerAllocator2> & rhs)
+{
+  return lhs.name == rhs.name &&
+    lhs.offset == rhs.offset &&
+    lhs.datatype == rhs.datatype &&
+    lhs.count == rhs.count;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::PointField_<ContainerAllocator1> & lhs, const ::sensor_msgs::PointField_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::PointField_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::PointField_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::PointField_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::PointField_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::PointField_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::PointField_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::PointField_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "268eacb2962780ceac86cbd17e328150";
+  }
+
+  static const char* value(const ::sensor_msgs::PointField_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x268eacb2962780ceULL;
+  static const uint64_t static_value2 = 0xac86cbd17e328150ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::PointField_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/PointField";
+  }
+
+  static const char* value(const ::sensor_msgs::PointField_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::PointField_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# This message holds the description of one point entry in the\n"
+"# PointCloud2 message format.\n"
+"uint8 INT8    = 1\n"
+"uint8 UINT8   = 2\n"
+"uint8 INT16   = 3\n"
+"uint8 UINT16  = 4\n"
+"uint8 INT32   = 5\n"
+"uint8 UINT32  = 6\n"
+"uint8 FLOAT32 = 7\n"
+"uint8 FLOAT64 = 8\n"
+"\n"
+"string name      # Name of field\n"
+"uint32 offset    # Offset from start of point struct\n"
+"uint8  datatype  # Datatype enumeration, see above\n"
+"uint32 count     # How many elements in the field\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::PointField_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::PointField_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.name);
+      stream.next(m.offset);
+      stream.next(m.datatype);
+      stream.next(m.count);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct PointField_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::PointField_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::PointField_<ContainerAllocator>& v)
+  {
+    s << indent << "name: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>::stream(s, indent + "  ", v.name);
+    s << indent << "offset: ";
+    Printer<uint32_t>::stream(s, indent + "  ", v.offset);
+    s << indent << "datatype: ";
+    Printer<uint8_t>::stream(s, indent + "  ", v.datatype);
+    s << indent << "count: ";
+    Printer<uint32_t>::stream(s, indent + "  ", v.count);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_POINTFIELD_H

thirdparty/ros/include/sensor_msgs/Range.h

@@ -0,0 +1,312 @@
+// Generated by gencpp from file sensor_msgs/Range.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_RANGE_H
+#define SENSOR_MSGS_MESSAGE_RANGE_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <std_msgs/Header.h>
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct Range_
+{
+  typedef Range_<ContainerAllocator> Type;
+
+  Range_()
+    : header()
+    , radiation_type(0)
+    , field_of_view(0.0)
+    , min_range(0.0)
+    , max_range(0.0)
+    , range(0.0)  {
+    }
+  Range_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , radiation_type(0)
+    , field_of_view(0.0)
+    , min_range(0.0)
+    , max_range(0.0)
+    , range(0.0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
+  _header_type header;
+
+   typedef uint8_t _radiation_type_type;
+  _radiation_type_type radiation_type;
+
+   typedef float _field_of_view_type;
+  _field_of_view_type field_of_view;
+
+   typedef float _min_range_type;
+  _min_range_type min_range;
+
+   typedef float _max_range_type;
+  _max_range_type max_range;
+
+   typedef float _range_type;
+  _range_type range;
+
+
+
+// reducing the odds to have name collisions with Windows.h 
+#if defined(_WIN32) && defined(ULTRASOUND)
+  #undef ULTRASOUND
+#endif
+#if defined(_WIN32) && defined(INFRARED)
+  #undef INFRARED
+#endif
+
+  enum {
+    ULTRASOUND = 0u,
+    INFRARED = 1u,
+  };
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::Range_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::Range_<ContainerAllocator> const> ConstPtr;
+
+}; // struct Range_
+
+typedef ::sensor_msgs::Range_<std::allocator<void> > Range;
+
+typedef boost::shared_ptr< ::sensor_msgs::Range > RangePtr;
+typedef boost::shared_ptr< ::sensor_msgs::Range const> RangeConstPtr;
+
+// constants requiring out of line definition
+
+   
+
+   
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::Range_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::Range_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::Range_<ContainerAllocator1> & lhs, const ::sensor_msgs::Range_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.radiation_type == rhs.radiation_type &&
+    lhs.field_of_view == rhs.field_of_view &&
+    lhs.min_range == rhs.min_range &&
+    lhs.max_range == rhs.max_range &&
+    lhs.range == rhs.range;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::Range_<ContainerAllocator1> & lhs, const ::sensor_msgs::Range_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::Range_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::Range_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::Range_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::Range_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::Range_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::Range_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::Range_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "c005c34273dc426c67a020a87bc24148";
+  }
+
+  static const char* value(const ::sensor_msgs::Range_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0xc005c34273dc426cULL;
+  static const uint64_t static_value2 = 0x67a020a87bc24148ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::Range_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/Range";
+  }
+
+  static const char* value(const ::sensor_msgs::Range_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::Range_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# Single range reading from an active ranger that emits energy and reports\n"
+"# one range reading that is valid along an arc at the distance measured. \n"
+"# This message is  not appropriate for laser scanners. See the LaserScan\n"
+"# message if you are working with a laser scanner.\n"
+"\n"
+"# This message also can represent a fixed-distance (binary) ranger.  This\n"
+"# sensor will have min_range===max_range===distance of detection.\n"
+"# These sensors follow REP 117 and will output -Inf if the object is detected\n"
+"# and +Inf if the object is outside of the detection range.\n"
+"\n"
+"Header header           # timestamp in the header is the time the ranger\n"
+"                        # returned the distance reading\n"
+"\n"
+"# Radiation type enums\n"
+"# If you want a value added to this list, send an email to the ros-users list\n"
+"uint8 ULTRASOUND=0\n"
+"uint8 INFRARED=1\n"
+"\n"
+"uint8 radiation_type    # the type of radiation used by the sensor\n"
+"                        # (sound, IR, etc) [enum]\n"
+"\n"
+"float32 field_of_view   # the size of the arc that the distance reading is\n"
+"                        # valid for [rad]\n"
+"                        # the object causing the range reading may have\n"
+"                        # been anywhere within -field_of_view/2 and\n"
+"                        # field_of_view/2 at the measured range. \n"
+"                        # 0 angle corresponds to the x-axis of the sensor.\n"
+"\n"
+"float32 min_range       # minimum range value [m]\n"
+"float32 max_range       # maximum range value [m]\n"
+"                        # Fixed distance rangers require min_range==max_range\n"
+"\n"
+"float32 range           # range data [m]\n"
+"                        # (Note: values < range_min or > range_max\n"
+"                        # should be discarded)\n"
+"                        # Fixed distance rangers only output -Inf or +Inf.\n"
+"                        # -Inf represents a detection within fixed distance.\n"
+"                        # (Detection too close to the sensor to quantify)\n"
+"                        # +Inf represents no detection within the fixed distance.\n"
+"                        # (Object out of range)\n"
+"================================================================================\n"
+"MSG: std_msgs/Header\n"
+"# Standard metadata for higher-level stamped data types.\n"
+"# This is generally used to communicate timestamped data \n"
+"# in a particular coordinate frame.\n"
+"# \n"
+"# sequence ID: consecutively increasing ID \n"
+"uint32 seq\n"
+"#Two-integer timestamp that is expressed as:\n"
+"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
+"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
+"# time-handling sugar is provided by the client library\n"
+"time stamp\n"
+"#Frame this data is associated with\n"
+"string frame_id\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::Range_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::Range_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.header);
+      stream.next(m.radiation_type);
+      stream.next(m.field_of_view);
+      stream.next(m.min_range);
+      stream.next(m.max_range);
+      stream.next(m.range);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct Range_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::Range_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::Range_<ContainerAllocator>& v)
+  {
+    s << indent << "header: ";
+    s << std::endl;
+    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
+    s << indent << "radiation_type: ";
+    Printer<uint8_t>::stream(s, indent + "  ", v.radiation_type);
+    s << indent << "field_of_view: ";
+    Printer<float>::stream(s, indent + "  ", v.field_of_view);
+    s << indent << "min_range: ";
+    Printer<float>::stream(s, indent + "  ", v.min_range);
+    s << indent << "max_range: ";
+    Printer<float>::stream(s, indent + "  ", v.max_range);
+    s << indent << "range: ";
+    Printer<float>::stream(s, indent + "  ", v.range);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_RANGE_H

thirdparty/ros/include/sensor_msgs/RegionOfInterest.h

@@ -0,0 +1,249 @@
+// Generated by gencpp from file sensor_msgs/RegionOfInterest.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_REGIONOFINTEREST_H
+#define SENSOR_MSGS_MESSAGE_REGIONOFINTEREST_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct RegionOfInterest_
+{
+  typedef RegionOfInterest_<ContainerAllocator> Type;
+
+  RegionOfInterest_()
+    : x_offset(0)
+    , y_offset(0)
+    , height(0)
+    , width(0)
+    , do_rectify(false)  {
+    }
+  RegionOfInterest_(const ContainerAllocator& _alloc)
+    : x_offset(0)
+    , y_offset(0)
+    , height(0)
+    , width(0)
+    , do_rectify(false)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef uint32_t _x_offset_type;
+  _x_offset_type x_offset;
+
+   typedef uint32_t _y_offset_type;
+  _y_offset_type y_offset;
+
+   typedef uint32_t _height_type;
+  _height_type height;
+
+   typedef uint32_t _width_type;
+  _width_type width;
+
+   typedef uint8_t _do_rectify_type;
+  _do_rectify_type do_rectify;
+
+
+
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> const> ConstPtr;
+
+}; // struct RegionOfInterest_
+
+typedef ::sensor_msgs::RegionOfInterest_<std::allocator<void> > RegionOfInterest;
+
+typedef boost::shared_ptr< ::sensor_msgs::RegionOfInterest > RegionOfInterestPtr;
+typedef boost::shared_ptr< ::sensor_msgs::RegionOfInterest const> RegionOfInterestConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::RegionOfInterest_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::RegionOfInterest_<ContainerAllocator1> & lhs, const ::sensor_msgs::RegionOfInterest_<ContainerAllocator2> & rhs)
+{
+  return lhs.x_offset == rhs.x_offset &&
+    lhs.y_offset == rhs.y_offset &&
+    lhs.height == rhs.height &&
+    lhs.width == rhs.width &&
+    lhs.do_rectify == rhs.do_rectify;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::RegionOfInterest_<ContainerAllocator1> & lhs, const ::sensor_msgs::RegionOfInterest_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "bdb633039d588fcccb441a4d43ccfe09";
+  }
+
+  static const char* value(const ::sensor_msgs::RegionOfInterest_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0xbdb633039d588fccULL;
+  static const uint64_t static_value2 = 0xcb441a4d43ccfe09ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/RegionOfInterest";
+  }
+
+  static const char* value(const ::sensor_msgs::RegionOfInterest_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# This message is used to specify a region of interest within an image.\n"
+"#\n"
+"# When used to specify the ROI setting of the camera when the image was\n"
+"# taken, the height and width fields should either match the height and\n"
+"# width fields for the associated image; or height = width = 0\n"
+"# indicates that the full resolution image was captured.\n"
+"\n"
+"uint32 x_offset  # Leftmost pixel of the ROI\n"
+"                 # (0 if the ROI includes the left edge of the image)\n"
+"uint32 y_offset  # Topmost pixel of the ROI\n"
+"                 # (0 if the ROI includes the top edge of the image)\n"
+"uint32 height    # Height of ROI\n"
+"uint32 width     # Width of ROI\n"
+"\n"
+"# True if a distinct rectified ROI should be calculated from the \"raw\"\n"
+"# ROI in this message. Typically this should be False if the full image\n"
+"# is captured (ROI not used), and True if a subwindow is captured (ROI\n"
+"# used).\n"
+"bool do_rectify\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::RegionOfInterest_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.x_offset);
+      stream.next(m.y_offset);
+      stream.next(m.height);
+      stream.next(m.width);
+      stream.next(m.do_rectify);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct RegionOfInterest_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::RegionOfInterest_<ContainerAllocator>& v)
+  {
+    s << indent << "x_offset: ";
+    Printer<uint32_t>::stream(s, indent + "  ", v.x_offset);
+    s << indent << "y_offset: ";
+    Printer<uint32_t>::stream(s, indent + "  ", v.y_offset);
+    s << indent << "height: ";
+    Printer<uint32_t>::stream(s, indent + "  ", v.height);
+    s << indent << "width: ";
+    Printer<uint32_t>::stream(s, indent + "  ", v.width);
+    s << indent << "do_rectify: ";
+    Printer<uint8_t>::stream(s, indent + "  ", v.do_rectify);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_REGIONOFINTEREST_H

thirdparty/ros/include/sensor_msgs/RelativeHumidity.h

@@ -0,0 +1,241 @@
+// Generated by gencpp from file sensor_msgs/RelativeHumidity.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_RELATIVEHUMIDITY_H
+#define SENSOR_MSGS_MESSAGE_RELATIVEHUMIDITY_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <std_msgs/Header.h>
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct RelativeHumidity_
+{
+  typedef RelativeHumidity_<ContainerAllocator> Type;
+
+  RelativeHumidity_()
+    : header()
+    , relative_humidity(0.0)
+    , variance(0.0)  {
+    }
+  RelativeHumidity_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , relative_humidity(0.0)
+    , variance(0.0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
+  _header_type header;
+
+   typedef double _relative_humidity_type;
+  _relative_humidity_type relative_humidity;
+
+   typedef double _variance_type;
+  _variance_type variance;
+
+
+
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::RelativeHumidity_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::RelativeHumidity_<ContainerAllocator> const> ConstPtr;
+
+}; // struct RelativeHumidity_
+
+typedef ::sensor_msgs::RelativeHumidity_<std::allocator<void> > RelativeHumidity;
+
+typedef boost::shared_ptr< ::sensor_msgs::RelativeHumidity > RelativeHumidityPtr;
+typedef boost::shared_ptr< ::sensor_msgs::RelativeHumidity const> RelativeHumidityConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::RelativeHumidity_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::RelativeHumidity_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::RelativeHumidity_<ContainerAllocator1> & lhs, const ::sensor_msgs::RelativeHumidity_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.relative_humidity == rhs.relative_humidity &&
+    lhs.variance == rhs.variance;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::RelativeHumidity_<ContainerAllocator1> & lhs, const ::sensor_msgs::RelativeHumidity_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::RelativeHumidity_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::RelativeHumidity_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::RelativeHumidity_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::RelativeHumidity_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::RelativeHumidity_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::RelativeHumidity_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::RelativeHumidity_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "8730015b05955b7e992ce29a2678d90f";
+  }
+
+  static const char* value(const ::sensor_msgs::RelativeHumidity_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x8730015b05955b7eULL;
+  static const uint64_t static_value2 = 0x992ce29a2678d90fULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::RelativeHumidity_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/RelativeHumidity";
+  }
+
+  static const char* value(const ::sensor_msgs::RelativeHumidity_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::RelativeHumidity_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return " # Single reading from a relative humidity sensor.  Defines the ratio of partial\n"
+" # pressure of water vapor to the saturated vapor pressure at a temperature.\n"
+"\n"
+" Header header             # timestamp of the measurement\n"
+"                           # frame_id is the location of the humidity sensor\n"
+"\n"
+" float64 relative_humidity # Expression of the relative humidity\n"
+"                           # from 0.0 to 1.0.\n"
+"                           # 0.0 is no partial pressure of water vapor\n"
+"                           # 1.0 represents partial pressure of saturation\n"
+"\n"
+" float64 variance          # 0 is interpreted as variance unknown\n"
+"================================================================================\n"
+"MSG: std_msgs/Header\n"
+"# Standard metadata for higher-level stamped data types.\n"
+"# This is generally used to communicate timestamped data \n"
+"# in a particular coordinate frame.\n"
+"# \n"
+"# sequence ID: consecutively increasing ID \n"
+"uint32 seq\n"
+"#Two-integer timestamp that is expressed as:\n"
+"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
+"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
+"# time-handling sugar is provided by the client library\n"
+"time stamp\n"
+"#Frame this data is associated with\n"
+"string frame_id\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::RelativeHumidity_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::RelativeHumidity_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.header);
+      stream.next(m.relative_humidity);
+      stream.next(m.variance);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct RelativeHumidity_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::RelativeHumidity_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::RelativeHumidity_<ContainerAllocator>& v)
+  {
+    s << indent << "header: ";
+    s << std::endl;
+    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
+    s << indent << "relative_humidity: ";
+    Printer<double>::stream(s, indent + "  ", v.relative_humidity);
+    s << indent << "variance: ";
+    Printer<double>::stream(s, indent + "  ", v.variance);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_RELATIVEHUMIDITY_H

thirdparty/ros/include/sensor_msgs/SetCameraInfo.h

@@ -0,0 +1,123 @@
+// Generated by gencpp from file sensor_msgs/SetCameraInfo.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_SETCAMERAINFO_H
+#define SENSOR_MSGS_MESSAGE_SETCAMERAINFO_H
+
+#include <ros/service_traits.h>
+
+
+#include <sensor_msgs/SetCameraInfoRequest.h>
+#include <sensor_msgs/SetCameraInfoResponse.h>
+
+
+namespace sensor_msgs
+{
+
+struct SetCameraInfo
+{
+
+typedef SetCameraInfoRequest Request;
+typedef SetCameraInfoResponse Response;
+Request request;
+Response response;
+
+typedef Request RequestType;
+typedef Response ResponseType;
+
+}; // struct SetCameraInfo
+} // namespace sensor_msgs
+
+
+namespace ros
+{
+namespace service_traits
+{
+
+
+template<>
+struct MD5Sum< ::sensor_msgs::SetCameraInfo > {
+  static const char* value()
+  {
+    return "bef1df590ed75ed1f393692395e15482";
+  }
+
+  static const char* value(const ::sensor_msgs::SetCameraInfo&) { return value(); }
+};
+
+template<>
+struct DataType< ::sensor_msgs::SetCameraInfo > {
+  static const char* value()
+  {
+    return "sensor_msgs/SetCameraInfo";
+  }
+
+  static const char* value(const ::sensor_msgs::SetCameraInfo&) { return value(); }
+};
+
+
+// service_traits::MD5Sum< ::sensor_msgs::SetCameraInfoRequest> should match
+// service_traits::MD5Sum< ::sensor_msgs::SetCameraInfo >
+template<>
+struct MD5Sum< ::sensor_msgs::SetCameraInfoRequest>
+{
+  static const char* value()
+  {
+    return MD5Sum< ::sensor_msgs::SetCameraInfo >::value();
+  }
+  static const char* value(const ::sensor_msgs::SetCameraInfoRequest&)
+  {
+    return value();
+  }
+};
+
+// service_traits::DataType< ::sensor_msgs::SetCameraInfoRequest> should match
+// service_traits::DataType< ::sensor_msgs::SetCameraInfo >
+template<>
+struct DataType< ::sensor_msgs::SetCameraInfoRequest>
+{
+  static const char* value()
+  {
+    return DataType< ::sensor_msgs::SetCameraInfo >::value();
+  }
+  static const char* value(const ::sensor_msgs::SetCameraInfoRequest&)
+  {
+    return value();
+  }
+};
+
+// service_traits::MD5Sum< ::sensor_msgs::SetCameraInfoResponse> should match
+// service_traits::MD5Sum< ::sensor_msgs::SetCameraInfo >
+template<>
+struct MD5Sum< ::sensor_msgs::SetCameraInfoResponse>
+{
+  static const char* value()
+  {
+    return MD5Sum< ::sensor_msgs::SetCameraInfo >::value();
+  }
+  static const char* value(const ::sensor_msgs::SetCameraInfoResponse&)
+  {
+    return value();
+  }
+};
+
+// service_traits::DataType< ::sensor_msgs::SetCameraInfoResponse> should match
+// service_traits::DataType< ::sensor_msgs::SetCameraInfo >
+template<>
+struct DataType< ::sensor_msgs::SetCameraInfoResponse>
+{
+  static const char* value()
+  {
+    return DataType< ::sensor_msgs::SetCameraInfo >::value();
+  }
+  static const char* value(const ::sensor_msgs::SetCameraInfoResponse&)
+  {
+    return value();
+  }
+};
+
+} // namespace service_traits
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_SETCAMERAINFO_H

thirdparty/ros/include/sensor_msgs/SetCameraInfoRequest.h

@@ -0,0 +1,377 @@
+// Generated by gencpp from file sensor_msgs/SetCameraInfoRequest.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_SETCAMERAINFOREQUEST_H
+#define SENSOR_MSGS_MESSAGE_SETCAMERAINFOREQUEST_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <sensor_msgs/CameraInfo.h>
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct SetCameraInfoRequest_
+{
+  typedef SetCameraInfoRequest_<ContainerAllocator> Type;
+
+  SetCameraInfoRequest_()
+    : camera_info()  {
+    }
+  SetCameraInfoRequest_(const ContainerAllocator& _alloc)
+    : camera_info(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::sensor_msgs::CameraInfo_<ContainerAllocator>  _camera_info_type;
+  _camera_info_type camera_info;
+
+
+
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> const> ConstPtr;
+
+}; // struct SetCameraInfoRequest_
+
+typedef ::sensor_msgs::SetCameraInfoRequest_<std::allocator<void> > SetCameraInfoRequest;
+
+typedef boost::shared_ptr< ::sensor_msgs::SetCameraInfoRequest > SetCameraInfoRequestPtr;
+typedef boost::shared_ptr< ::sensor_msgs::SetCameraInfoRequest const> SetCameraInfoRequestConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator1> & lhs, const ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator2> & rhs)
+{
+  return lhs.camera_info == rhs.camera_info;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator1> & lhs, const ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "ee34be01fdeee563d0d99cd594d5581d";
+  }
+
+  static const char* value(const ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0xee34be01fdeee563ULL;
+  static const uint64_t static_value2 = 0xd0d99cd594d5581dULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/SetCameraInfoRequest";
+  }
+
+  static const char* value(const ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# This service requests that a camera stores the given CameraInfo \n"
+"# as that camera's calibration information.\n"
+"#\n"
+"# The width and height in the camera_info field should match what the\n"
+"# camera is currently outputting on its camera_info topic, and the camera\n"
+"# will assume that the region of the imager that is being referred to is\n"
+"# the region that the camera is currently capturing.\n"
+"\n"
+"sensor_msgs/CameraInfo camera_info # The camera_info to store\n"
+"\n"
+"================================================================================\n"
+"MSG: sensor_msgs/CameraInfo\n"
+"# This message defines meta information for a camera. It should be in a\n"
+"# camera namespace on topic \"camera_info\" and accompanied by up to five\n"
+"# image topics named:\n"
+"#\n"
+"#   image_raw - raw data from the camera driver, possibly Bayer encoded\n"
+"#   image            - monochrome, distorted\n"
+"#   image_color      - color, distorted\n"
+"#   image_rect       - monochrome, rectified\n"
+"#   image_rect_color - color, rectified\n"
+"#\n"
+"# The image_pipeline contains packages (image_proc, stereo_image_proc)\n"
+"# for producing the four processed image topics from image_raw and\n"
+"# camera_info. The meaning of the camera parameters are described in\n"
+"# detail at http://www.ros.org/wiki/image_pipeline/CameraInfo.\n"
+"#\n"
+"# The image_geometry package provides a user-friendly interface to\n"
+"# common operations using this meta information. If you want to, e.g.,\n"
+"# project a 3d point into image coordinates, we strongly recommend\n"
+"# using image_geometry.\n"
+"#\n"
+"# If the camera is uncalibrated, the matrices D, K, R, P should be left\n"
+"# zeroed out. In particular, clients may assume that K[0] == 0.0\n"
+"# indicates an uncalibrated camera.\n"
+"\n"
+"#######################################################################\n"
+"#                     Image acquisition info                          #\n"
+"#######################################################################\n"
+"\n"
+"# Time of image acquisition, camera coordinate frame ID\n"
+"Header header    # Header timestamp should be acquisition time of image\n"
+"                 # Header frame_id should be optical frame of camera\n"
+"                 # origin of frame should be optical center of camera\n"
+"                 # +x should point to the right in the image\n"
+"                 # +y should point down in the image\n"
+"                 # +z should point into the plane of the image\n"
+"\n"
+"\n"
+"#######################################################################\n"
+"#                      Calibration Parameters                         #\n"
+"#######################################################################\n"
+"# These are fixed during camera calibration. Their values will be the #\n"
+"# same in all messages until the camera is recalibrated. Note that    #\n"
+"# self-calibrating systems may \"recalibrate\" frequently.              #\n"
+"#                                                                     #\n"
+"# The internal parameters can be used to warp a raw (distorted) image #\n"
+"# to:                                                                 #\n"
+"#   1. An undistorted image (requires D and K)                        #\n"
+"#   2. A rectified image (requires D, K, R)                           #\n"
+"# The projection matrix P projects 3D points into the rectified image.#\n"
+"#######################################################################\n"
+"\n"
+"# The image dimensions with which the camera was calibrated. Normally\n"
+"# this will be the full camera resolution in pixels.\n"
+"uint32 height\n"
+"uint32 width\n"
+"\n"
+"# The distortion model used. Supported models are listed in\n"
+"# sensor_msgs/distortion_models.h. For most cameras, \"plumb_bob\" - a\n"
+"# simple model of radial and tangential distortion - is sufficient.\n"
+"string distortion_model\n"
+"\n"
+"# The distortion parameters, size depending on the distortion model.\n"
+"# For \"plumb_bob\", the 5 parameters are: (k1, k2, t1, t2, k3).\n"
+"float64[] D\n"
+"\n"
+"# Intrinsic camera matrix for the raw (distorted) images.\n"
+"#     [fx  0 cx]\n"
+"# K = [ 0 fy cy]\n"
+"#     [ 0  0  1]\n"
+"# Projects 3D points in the camera coordinate frame to 2D pixel\n"
+"# coordinates using the focal lengths (fx, fy) and principal point\n"
+"# (cx, cy).\n"
+"float64[9]  K # 3x3 row-major matrix\n"
+"\n"
+"# Rectification matrix (stereo cameras only)\n"
+"# A rotation matrix aligning the camera coordinate system to the ideal\n"
+"# stereo image plane so that epipolar lines in both stereo images are\n"
+"# parallel.\n"
+"float64[9]  R # 3x3 row-major matrix\n"
+"\n"
+"# Projection/camera matrix\n"
+"#     [fx'  0  cx' Tx]\n"
+"# P = [ 0  fy' cy' Ty]\n"
+"#     [ 0   0   1   0]\n"
+"# By convention, this matrix specifies the intrinsic (camera) matrix\n"
+"#  of the processed (rectified) image. That is, the left 3x3 portion\n"
+"#  is the normal camera intrinsic matrix for the rectified image.\n"
+"# It projects 3D points in the camera coordinate frame to 2D pixel\n"
+"#  coordinates using the focal lengths (fx', fy') and principal point\n"
+"#  (cx', cy') - these may differ from the values in K.\n"
+"# For monocular cameras, Tx = Ty = 0. Normally, monocular cameras will\n"
+"#  also have R = the identity and P[1:3,1:3] = K.\n"
+"# For a stereo pair, the fourth column [Tx Ty 0]' is related to the\n"
+"#  position of the optical center of the second camera in the first\n"
+"#  camera's frame. We assume Tz = 0 so both cameras are in the same\n"
+"#  stereo image plane. The first camera always has Tx = Ty = 0. For\n"
+"#  the right (second) camera of a horizontal stereo pair, Ty = 0 and\n"
+"#  Tx = -fx' * B, where B is the baseline between the cameras.\n"
+"# Given a 3D point [X Y Z]', the projection (x, y) of the point onto\n"
+"#  the rectified image is given by:\n"
+"#  [u v w]' = P * [X Y Z 1]'\n"
+"#         x = u / w\n"
+"#         y = v / w\n"
+"#  This holds for both images of a stereo pair.\n"
+"float64[12] P # 3x4 row-major matrix\n"
+"\n"
+"\n"
+"#######################################################################\n"
+"#                      Operational Parameters                         #\n"
+"#######################################################################\n"
+"# These define the image region actually captured by the camera       #\n"
+"# driver. Although they affect the geometry of the output image, they #\n"
+"# may be changed freely without recalibrating the camera.             #\n"
+"#######################################################################\n"
+"\n"
+"# Binning refers here to any camera setting which combines rectangular\n"
+"#  neighborhoods of pixels into larger \"super-pixels.\" It reduces the\n"
+"#  resolution of the output image to\n"
+"#  (width / binning_x) x (height / binning_y).\n"
+"# The default values binning_x = binning_y = 0 is considered the same\n"
+"#  as binning_x = binning_y = 1 (no subsampling).\n"
+"uint32 binning_x\n"
+"uint32 binning_y\n"
+"\n"
+"# Region of interest (subwindow of full camera resolution), given in\n"
+"#  full resolution (unbinned) image coordinates. A particular ROI\n"
+"#  always denotes the same window of pixels on the camera sensor,\n"
+"#  regardless of binning settings.\n"
+"# The default setting of roi (all values 0) is considered the same as\n"
+"#  full resolution (roi.width = width, roi.height = height).\n"
+"RegionOfInterest roi\n"
+"\n"
+"================================================================================\n"
+"MSG: std_msgs/Header\n"
+"# Standard metadata for higher-level stamped data types.\n"
+"# This is generally used to communicate timestamped data \n"
+"# in a particular coordinate frame.\n"
+"# \n"
+"# sequence ID: consecutively increasing ID \n"
+"uint32 seq\n"
+"#Two-integer timestamp that is expressed as:\n"
+"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
+"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
+"# time-handling sugar is provided by the client library\n"
+"time stamp\n"
+"#Frame this data is associated with\n"
+"string frame_id\n"
+"\n"
+"================================================================================\n"
+"MSG: sensor_msgs/RegionOfInterest\n"
+"# This message is used to specify a region of interest within an image.\n"
+"#\n"
+"# When used to specify the ROI setting of the camera when the image was\n"
+"# taken, the height and width fields should either match the height and\n"
+"# width fields for the associated image; or height = width = 0\n"
+"# indicates that the full resolution image was captured.\n"
+"\n"
+"uint32 x_offset  # Leftmost pixel of the ROI\n"
+"                 # (0 if the ROI includes the left edge of the image)\n"
+"uint32 y_offset  # Topmost pixel of the ROI\n"
+"                 # (0 if the ROI includes the top edge of the image)\n"
+"uint32 height    # Height of ROI\n"
+"uint32 width     # Width of ROI\n"
+"\n"
+"# True if a distinct rectified ROI should be calculated from the \"raw\"\n"
+"# ROI in this message. Typically this should be False if the full image\n"
+"# is captured (ROI not used), and True if a subwindow is captured (ROI\n"
+"# used).\n"
+"bool do_rectify\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.camera_info);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct SetCameraInfoRequest_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator>& v)
+  {
+    s << indent << "camera_info: ";
+    s << std::endl;
+    Printer< ::sensor_msgs::CameraInfo_<ContainerAllocator> >::stream(s, indent + "  ", v.camera_info);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_SETCAMERAINFOREQUEST_H

thirdparty/ros/include/sensor_msgs/SetCameraInfoResponse.h

@@ -0,0 +1,206 @@
+// Generated by gencpp from file sensor_msgs/SetCameraInfoResponse.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_SETCAMERAINFORESPONSE_H
+#define SENSOR_MSGS_MESSAGE_SETCAMERAINFORESPONSE_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct SetCameraInfoResponse_
+{
+  typedef SetCameraInfoResponse_<ContainerAllocator> Type;
+
+  SetCameraInfoResponse_()
+    : success(false)
+    , status_message()  {
+    }
+  SetCameraInfoResponse_(const ContainerAllocator& _alloc)
+    : success(false)
+    , status_message(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef uint8_t _success_type;
+  _success_type success;
+
+   typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _status_message_type;
+  _status_message_type status_message;
+
+
+
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> const> ConstPtr;
+
+}; // struct SetCameraInfoResponse_
+
+typedef ::sensor_msgs::SetCameraInfoResponse_<std::allocator<void> > SetCameraInfoResponse;
+
+typedef boost::shared_ptr< ::sensor_msgs::SetCameraInfoResponse > SetCameraInfoResponsePtr;
+typedef boost::shared_ptr< ::sensor_msgs::SetCameraInfoResponse const> SetCameraInfoResponseConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator1> & lhs, const ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator2> & rhs)
+{
+  return lhs.success == rhs.success &&
+    lhs.status_message == rhs.status_message;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator1> & lhs, const ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "2ec6f3eff0161f4257b808b12bc830c2";
+  }
+
+  static const char* value(const ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x2ec6f3eff0161f42ULL;
+  static const uint64_t static_value2 = 0x57b808b12bc830c2ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/SetCameraInfoResponse";
+  }
+
+  static const char* value(const ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "bool success          # True if the call succeeded\n"
+"string status_message # Used to give details about success\n"
+"\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.success);
+      stream.next(m.status_message);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct SetCameraInfoResponse_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator>& v)
+  {
+    s << indent << "success: ";
+    Printer<uint8_t>::stream(s, indent + "  ", v.success);
+    s << indent << "status_message: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>::stream(s, indent + "  ", v.status_message);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_SETCAMERAINFORESPONSE_H

thirdparty/ros/include/sensor_msgs/Temperature.h

@@ -0,0 +1,237 @@
+// Generated by gencpp from file sensor_msgs/Temperature.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_TEMPERATURE_H
+#define SENSOR_MSGS_MESSAGE_TEMPERATURE_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <std_msgs/Header.h>
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct Temperature_
+{
+  typedef Temperature_<ContainerAllocator> Type;
+
+  Temperature_()
+    : header()
+    , temperature(0.0)
+    , variance(0.0)  {
+    }
+  Temperature_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , temperature(0.0)
+    , variance(0.0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
+  _header_type header;
+
+   typedef double _temperature_type;
+  _temperature_type temperature;
+
+   typedef double _variance_type;
+  _variance_type variance;
+
+
+
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::Temperature_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::Temperature_<ContainerAllocator> const> ConstPtr;
+
+}; // struct Temperature_
+
+typedef ::sensor_msgs::Temperature_<std::allocator<void> > Temperature;
+
+typedef boost::shared_ptr< ::sensor_msgs::Temperature > TemperaturePtr;
+typedef boost::shared_ptr< ::sensor_msgs::Temperature const> TemperatureConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::Temperature_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::Temperature_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::Temperature_<ContainerAllocator1> & lhs, const ::sensor_msgs::Temperature_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.temperature == rhs.temperature &&
+    lhs.variance == rhs.variance;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::Temperature_<ContainerAllocator1> & lhs, const ::sensor_msgs::Temperature_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::Temperature_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::Temperature_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::Temperature_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::Temperature_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::Temperature_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::Temperature_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::Temperature_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "ff71b307acdbe7c871a5a6d7ed359100";
+  }
+
+  static const char* value(const ::sensor_msgs::Temperature_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0xff71b307acdbe7c8ULL;
+  static const uint64_t static_value2 = 0x71a5a6d7ed359100ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::Temperature_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/Temperature";
+  }
+
+  static const char* value(const ::sensor_msgs::Temperature_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::Temperature_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return " # Single temperature reading.\n"
+"\n"
+" Header header           # timestamp is the time the temperature was measured\n"
+"                         # frame_id is the location of the temperature reading\n"
+"\n"
+" float64 temperature     # Measurement of the Temperature in Degrees Celsius\n"
+"\n"
+" float64 variance        # 0 is interpreted as variance unknown\n"
+"================================================================================\n"
+"MSG: std_msgs/Header\n"
+"# Standard metadata for higher-level stamped data types.\n"
+"# This is generally used to communicate timestamped data \n"
+"# in a particular coordinate frame.\n"
+"# \n"
+"# sequence ID: consecutively increasing ID \n"
+"uint32 seq\n"
+"#Two-integer timestamp that is expressed as:\n"
+"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
+"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
+"# time-handling sugar is provided by the client library\n"
+"time stamp\n"
+"#Frame this data is associated with\n"
+"string frame_id\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::Temperature_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::Temperature_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.header);
+      stream.next(m.temperature);
+      stream.next(m.variance);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct Temperature_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::Temperature_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::Temperature_<ContainerAllocator>& v)
+  {
+    s << indent << "header: ";
+    s << std::endl;
+    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
+    s << indent << "temperature: ";
+    Printer<double>::stream(s, indent + "  ", v.temperature);
+    s << indent << "variance: ";
+    Printer<double>::stream(s, indent + "  ", v.variance);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_TEMPERATURE_H

thirdparty/ros/include/sensor_msgs/TimeReference.h

@@ -0,0 +1,237 @@
+// Generated by gencpp from file sensor_msgs/TimeReference.msg
+// DO NOT EDIT!
+
+
+#ifndef SENSOR_MSGS_MESSAGE_TIMEREFERENCE_H
+#define SENSOR_MSGS_MESSAGE_TIMEREFERENCE_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <std_msgs/Header.h>
+
+namespace sensor_msgs
+{
+template <class ContainerAllocator>
+struct TimeReference_
+{
+  typedef TimeReference_<ContainerAllocator> Type;
+
+  TimeReference_()
+    : header()
+    , time_ref()
+    , source()  {
+    }
+  TimeReference_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , time_ref()
+    , source(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
+  _header_type header;
+
+   typedef ros::Time _time_ref_type;
+  _time_ref_type time_ref;
+
+   typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _source_type;
+  _source_type source;
+
+
+
+
+
+  typedef boost::shared_ptr< ::sensor_msgs::TimeReference_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::sensor_msgs::TimeReference_<ContainerAllocator> const> ConstPtr;
+
+}; // struct TimeReference_
+
+typedef ::sensor_msgs::TimeReference_<std::allocator<void> > TimeReference;
+
+typedef boost::shared_ptr< ::sensor_msgs::TimeReference > TimeReferencePtr;
+typedef boost::shared_ptr< ::sensor_msgs::TimeReference const> TimeReferenceConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::TimeReference_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::sensor_msgs::TimeReference_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::sensor_msgs::TimeReference_<ContainerAllocator1> & lhs, const ::sensor_msgs::TimeReference_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.time_ref == rhs.time_ref &&
+    lhs.source == rhs.source;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::sensor_msgs::TimeReference_<ContainerAllocator1> & lhs, const ::sensor_msgs::TimeReference_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace sensor_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::TimeReference_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::sensor_msgs::TimeReference_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::TimeReference_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::sensor_msgs::TimeReference_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::TimeReference_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::sensor_msgs::TimeReference_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::sensor_msgs::TimeReference_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "fded64a0265108ba86c3d38fb11c0c16";
+  }
+
+  static const char* value(const ::sensor_msgs::TimeReference_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0xfded64a0265108baULL;
+  static const uint64_t static_value2 = 0x86c3d38fb11c0c16ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::sensor_msgs::TimeReference_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "sensor_msgs/TimeReference";
+  }
+
+  static const char* value(const ::sensor_msgs::TimeReference_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::sensor_msgs::TimeReference_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# Measurement from an external time source not actively synchronized with the system clock.\n"
+"\n"
+"Header header    # stamp is system time for which measurement was valid\n"
+"                 # frame_id is not used \n"
+"\n"
+"time   time_ref  # corresponding time from this external source\n"
+"string source    # (optional) name of time source\n"
+"\n"
+"================================================================================\n"
+"MSG: std_msgs/Header\n"
+"# Standard metadata for higher-level stamped data types.\n"
+"# This is generally used to communicate timestamped data \n"
+"# in a particular coordinate frame.\n"
+"# \n"
+"# sequence ID: consecutively increasing ID \n"
+"uint32 seq\n"
+"#Two-integer timestamp that is expressed as:\n"
+"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
+"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
+"# time-handling sugar is provided by the client library\n"
+"time stamp\n"
+"#Frame this data is associated with\n"
+"string frame_id\n"
+;
+  }
+
+  static const char* value(const ::sensor_msgs::TimeReference_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::sensor_msgs::TimeReference_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.header);
+      stream.next(m.time_ref);
+      stream.next(m.source);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct TimeReference_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::sensor_msgs::TimeReference_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::TimeReference_<ContainerAllocator>& v)
+  {
+    s << indent << "header: ";
+    s << std::endl;
+    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
+    s << indent << "time_ref: ";
+    Printer<ros::Time>::stream(s, indent + "  ", v.time_ref);
+    s << indent << "source: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>::stream(s, indent + "  ", v.source);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // SENSOR_MSGS_MESSAGE_TIMEREFERENCE_H

thirdparty/ros/include/sensor_msgs/distortion_models.h

@@ -0,0 +1,51 @@
+
+/*********************************************************************
+* Software License Agreement (BSD License)
+* 
+*  Copyright (c) 2010, Willow Garage, Inc.
+*  All rights reserved.
+* 
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+* 
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of the Willow Garage nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+* 
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+
+#ifndef SENSOR_MSGS_DISTORTION_MODELS_H
+#define SENSOR_MSGS_DISTORTION_MODELS_H
+
+#include <string>
+
+namespace sensor_msgs
+{
+  namespace distortion_models
+  {
+    const std::string PLUMB_BOB = "plumb_bob";
+    const std::string RATIONAL_POLYNOMIAL = "rational_polynomial";
+    const std::string EQUIDISTANT = "equidistant";
+  }
+}
+
+#endif

thirdparty/ros/include/sensor_msgs/fill_image.h

@@ -0,0 +1,70 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+* 
+*  Copyright (c) 2008, Willow Garage, Inc.
+*  All rights reserved.
+* 
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+* 
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of the Willow Garage nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+* 
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+
+#ifndef FILLIMAGE_HH
+#define FILLIMAGE_HH
+
+#include "sensor_msgs/Image.h"
+#include "sensor_msgs/image_encodings.h"
+
+namespace sensor_msgs
+{
+
+  static inline bool fillImage(Image& image,
+                 const std::string& encoding_arg,
+                 uint32_t rows_arg,
+                 uint32_t cols_arg,
+                 uint32_t step_arg,
+                 const void* data_arg)
+  {
+    image.encoding = encoding_arg;
+    image.height   = rows_arg;
+    image.width    = cols_arg;
+    image.step     = step_arg;
+    size_t st0 = (step_arg * rows_arg);
+    image.data.resize(st0);
+    memcpy(&image.data[0], data_arg, st0);
+
+    image.is_bigendian = 0;
+    return true;
+  }
+
+  static inline void clearImage(Image& image)
+  {
+    image.data.resize(0);
+  }
+}
+
+
+#endif

thirdparty/ros/include/sensor_msgs/image_encodings.h

@@ -0,0 +1,233 @@
+
+/*********************************************************************
+* Software License Agreement (BSD License)
+* 
+*  Copyright (c) 2009, Willow Garage, Inc.
+*  All rights reserved.
+* 
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+* 
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of the Willow Garage nor the names of its
+*     contributors may be used to endorse or promote products derived
+*     from this software without specific prior written permission.
+* 
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+
+#ifndef SENSOR_MSGS_IMAGE_ENCODINGS_H
+#define SENSOR_MSGS_IMAGE_ENCODINGS_H
+
+#include <cstdlib>
+#include <stdexcept>
+#include <string>
+
+namespace sensor_msgs
+{
+  namespace image_encodings
+  {
+    const std::string RGB8 = "rgb8";
+    const std::string RGBA8 = "rgba8";
+    const std::string RGB16 = "rgb16";
+    const std::string RGBA16 = "rgba16";
+    const std::string BGR8 = "bgr8";
+    const std::string BGRA8 = "bgra8";
+    const std::string BGR16 = "bgr16";
+    const std::string BGRA16 = "bgra16";
+    const std::string MONO8="mono8";
+    const std::string MONO16="mono16";
+
+    // OpenCV CvMat types
+    const std::string TYPE_8UC1="8UC1";
+    const std::string TYPE_8UC2="8UC2";
+    const std::string TYPE_8UC3="8UC3";
+    const std::string TYPE_8UC4="8UC4";
+    const std::string TYPE_8SC1="8SC1";
+    const std::string TYPE_8SC2="8SC2";
+    const std::string TYPE_8SC3="8SC3";
+    const std::string TYPE_8SC4="8SC4";
+    const std::string TYPE_16UC1="16UC1";
+    const std::string TYPE_16UC2="16UC2";
+    const std::string TYPE_16UC3="16UC3";
+    const std::string TYPE_16UC4="16UC4";
+    const std::string TYPE_16SC1="16SC1";
+    const std::string TYPE_16SC2="16SC2";
+    const std::string TYPE_16SC3="16SC3";
+    const std::string TYPE_16SC4="16SC4";
+    const std::string TYPE_32SC1="32SC1";
+    const std::string TYPE_32SC2="32SC2";
+    const std::string TYPE_32SC3="32SC3";
+    const std::string TYPE_32SC4="32SC4";
+    const std::string TYPE_32FC1="32FC1";
+    const std::string TYPE_32FC2="32FC2";
+    const std::string TYPE_32FC3="32FC3";
+    const std::string TYPE_32FC4="32FC4";
+    const std::string TYPE_64FC1="64FC1";
+    const std::string TYPE_64FC2="64FC2";
+    const std::string TYPE_64FC3="64FC3";
+    const std::string TYPE_64FC4="64FC4";
+
+    // Bayer encodings
+    const std::string BAYER_RGGB8="bayer_rggb8";
+    const std::string BAYER_BGGR8="bayer_bggr8";
+    const std::string BAYER_GBRG8="bayer_gbrg8";
+    const std::string BAYER_GRBG8="bayer_grbg8";
+    const std::string BAYER_RGGB16="bayer_rggb16";
+    const std::string BAYER_BGGR16="bayer_bggr16";
+    const std::string BAYER_GBRG16="bayer_gbrg16";
+    const std::string BAYER_GRBG16="bayer_grbg16";
+
+    // Miscellaneous
+    // This is the UYVY version of YUV422 codec http://www.fourcc.org/yuv.php#UYVY
+    // with an 8-bit depth
+    const std::string YUV422="yuv422";
+
+    // Prefixes for abstract image encodings
+    const std::string ABSTRACT_ENCODING_PREFIXES[] = {
+        "8UC", "8SC", "16UC", "16SC", "32SC", "32FC", "64FC"};
+
+    // Utility functions for inspecting an encoding string
+    static inline bool isColor(const std::string& encoding)
+    {
+      return encoding == RGB8  || encoding == BGR8 ||
+             encoding == RGBA8 || encoding == BGRA8 ||
+             encoding == RGB16 || encoding == BGR16 ||
+             encoding == RGBA16 || encoding == BGRA16;
+    }
+
+    static inline bool isMono(const std::string& encoding)
+    {
+      return encoding == MONO8 || encoding == MONO16;
+    }
+
+    static inline bool isBayer(const std::string& encoding)
+    {
+      return encoding == BAYER_RGGB8 || encoding == BAYER_BGGR8 ||
+             encoding == BAYER_GBRG8 || encoding == BAYER_GRBG8 ||
+             encoding == BAYER_RGGB16 || encoding == BAYER_BGGR16 ||
+             encoding == BAYER_GBRG16 || encoding == BAYER_GRBG16;
+    }
+
+    static inline bool hasAlpha(const std::string& encoding)
+    {
+      return encoding == RGBA8 || encoding == BGRA8 ||
+             encoding == RGBA16 || encoding == BGRA16;
+    }
+
+    static inline int numChannels(const std::string& encoding)
+    {
+      // First do the common-case encodings
+      if (encoding == MONO8 ||
+          encoding == MONO16)
+        return 1;
+      if (encoding == BGR8 ||
+          encoding == RGB8 ||
+          encoding == BGR16 ||
+          encoding == RGB16)
+        return 3;
+      if (encoding == BGRA8 ||
+          encoding == RGBA8 ||
+          encoding == BGRA16 ||
+          encoding == RGBA16)
+        return 4;
+      if (encoding == BAYER_RGGB8 ||
+          encoding == BAYER_BGGR8 ||
+          encoding == BAYER_GBRG8 ||
+          encoding == BAYER_GRBG8 ||
+          encoding == BAYER_RGGB16 ||
+          encoding == BAYER_BGGR16 ||
+          encoding == BAYER_GBRG16 ||
+          encoding == BAYER_GRBG16)
+        return 1;
+
+      // Now all the generic content encodings
+      // TODO: Rewrite with regex when ROS supports C++11
+      for (size_t i=0; i < sizeof(ABSTRACT_ENCODING_PREFIXES) / sizeof(*ABSTRACT_ENCODING_PREFIXES); i++)
+      {
+        std::string prefix = ABSTRACT_ENCODING_PREFIXES[i];
+        if (encoding.substr(0, prefix.size()) != prefix)
+          continue;
+        if (encoding.size() == prefix.size())
+          return 1;  // ex. 8UC -> 1
+        int n_channel = atoi(encoding.substr(prefix.size(),
+                                             encoding.size() - prefix.size()).c_str());  // ex. 8UC5 -> 5
+        if (n_channel != 0)
+          return n_channel;  // valid encoding string
+      }
+
+      if (encoding == YUV422)
+        return 2;
+
+      throw std::runtime_error("Unknown encoding " + encoding);
+      return -1;
+    }
+
+    static inline int bitDepth(const std::string& encoding)
+    {
+      if (encoding == MONO16)
+        return 16;
+      if (encoding == MONO8       ||
+          encoding == BGR8        ||
+          encoding == RGB8        ||
+          encoding == BGRA8       ||
+          encoding == RGBA8       ||
+          encoding == BAYER_RGGB8 ||
+          encoding == BAYER_BGGR8 ||
+          encoding == BAYER_GBRG8 ||
+          encoding == BAYER_GRBG8)
+        return 8;
+
+      if (encoding == MONO16       ||
+          encoding == BGR16        ||
+          encoding == RGB16        ||
+          encoding == BGRA16       ||
+          encoding == RGBA16       ||
+          encoding == BAYER_RGGB16 ||
+          encoding == BAYER_BGGR16 ||
+          encoding == BAYER_GBRG16 ||
+          encoding == BAYER_GRBG16)
+        return 16;
+
+      // Now all the generic content encodings
+      // TODO: Rewrite with regex when ROS supports C++11
+      for (size_t i=0; i < sizeof(ABSTRACT_ENCODING_PREFIXES) / sizeof(*ABSTRACT_ENCODING_PREFIXES); i++)
+      {
+        std::string prefix = ABSTRACT_ENCODING_PREFIXES[i];
+        if (encoding.substr(0, prefix.size()) != prefix)
+          continue;
+        if (encoding.size() == prefix.size())
+          return atoi(prefix.c_str());  // ex. 8UC -> 8
+        int n_channel = atoi(encoding.substr(prefix.size(),
+                                             encoding.size() - prefix.size()).c_str());  // ex. 8UC10 -> 10
+        if (n_channel != 0)
+          return atoi(prefix.c_str());  // valid encoding string
+      }
+
+      if (encoding == YUV422)
+        return 8;
+
+      throw std::runtime_error("Unknown encoding " + encoding);
+      return -1;
+    }
+  }
+}
+
+#endif

thirdparty/ros/include/sensor_msgs/impl/point_cloud2_iterator.h

@@ -0,0 +1,417 @@
+/*
+ * Software License Agreement (BSD License)
+ *
+ *  Copyright (c) 2013, Open Source Robotics Foundation
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of Open Source Robotics Foundation nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SENSOR_MSGS_IMPL_POINT_CLOUD_ITERATOR_H
+#define SENSOR_MSGS_IMPL_POINT_CLOUD_ITERATOR_H
+
+#include <sensor_msgs/PointCloud2.h>
+#include <cstdarg>
+#include <sstream>
+#include <string>
+#include <vector>
+
+/**
+ * \brief Private implementation used by PointCloud2Iterator
+ * \author Vincent Rabaud
+ */
+
+namespace
+{
+/** Return the size of a datatype (which is an enum of sensor_msgs::PointField::) in bytes
+ * @param datatype one of the enums of sensor_msgs::PointField::
+ */
+inline int sizeOfPointField(int datatype)
+{
+  if ((datatype == sensor_msgs::PointField::INT8) || (datatype == sensor_msgs::PointField::UINT8))
+    return 1;
+  else if ((datatype == sensor_msgs::PointField::INT16) || (datatype == sensor_msgs::PointField::UINT16))
+    return 2;
+  else if ((datatype == sensor_msgs::PointField::INT32) || (datatype == sensor_msgs::PointField::UINT32) ||
+      (datatype == sensor_msgs::PointField::FLOAT32))
+    return 4;
+  else if (datatype == sensor_msgs::PointField::FLOAT64)
+    return 8;
+  else
+  {
+    std::stringstream err;
+    err << "PointField of type " << datatype << " does not exist";
+    throw std::runtime_error(err.str());
+  }
+  return -1;
+}
+
+/** Private function that adds a PointField to the "fields" member of a PointCloud2
+ * @param cloud_msg the PointCloud2 to add a field to
+ * @param name the name of the field
+ * @param count the number of elements in the PointField
+ * @param datatype the datatype of the elements
+ * @param offset the offset of that element
+ * @return the offset of the next PointField that will be added to the PointCLoud2
+ */
+inline int addPointField(sensor_msgs::PointCloud2 &cloud_msg, const std::string &name, int count, int datatype,
+    int offset)
+{
+  sensor_msgs::PointField point_field;
+  point_field.name = name;
+  point_field.count = count;
+  point_field.datatype = datatype;
+  point_field.offset = offset;
+  cloud_msg.fields.push_back(point_field);
+
+  // Update the offset
+  return offset + point_field.count * sizeOfPointField(datatype);
+}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace sensor_msgs
+{
+
+inline PointCloud2Modifier::PointCloud2Modifier(PointCloud2& cloud_msg) : cloud_msg_(cloud_msg)
+{
+}
+
+inline size_t PointCloud2Modifier::size() const
+{
+  return cloud_msg_.data.size() / cloud_msg_.point_step;
+}
+
+inline void PointCloud2Modifier::reserve(size_t size)
+{
+  cloud_msg_.data.reserve(size * cloud_msg_.point_step);
+}
+
+inline void PointCloud2Modifier::resize(size_t size)
+{
+  cloud_msg_.data.resize(size * cloud_msg_.point_step);
+
+  // Update height/width
+  if (cloud_msg_.height == 1) {
+    cloud_msg_.width = size;
+    cloud_msg_.row_step = size * cloud_msg_.point_step;
+  } else
+    if (cloud_msg_.width == 1)
+      cloud_msg_.height = size;
+    else {
+      cloud_msg_.height = 1;
+      cloud_msg_.width = size;
+      cloud_msg_.row_step = size * cloud_msg_.point_step;
+    }
+}
+
+inline void PointCloud2Modifier::clear()
+{
+  cloud_msg_.data.clear();
+
+  // Update height/width
+  if (cloud_msg_.height == 1)
+    cloud_msg_.row_step = cloud_msg_.width = 0;
+  else
+    if (cloud_msg_.width == 1)
+      cloud_msg_.height = 0;
+    else
+      cloud_msg_.row_step = cloud_msg_.width = cloud_msg_.height = 0;
+}
+
+
+/**
+ * @brief Function setting some fields in a PointCloud and adjusting the
+ *        internals of the PointCloud2
+ * @param n_fields the number of fields to add. The fields are given as
+ *        triplets: name of the field as char*, number of elements in the
+ *        field, the datatype of the elements in the field
+ *
+ * E.g, you create your PointCloud2 message with XYZ/RGB as follows:
+ * <PRE>
+ *   setPointCloud2FieldsByString(cloud_msg, 4, "x", 1, sensor_msgs::PointField::FLOAT32,
+ *                                              "y", 1, sensor_msgs::PointField::FLOAT32,
+ *                                              "z", 1, sensor_msgs::PointField::FLOAT32,
+ *                                              "rgb", 1, sensor_msgs::PointField::FLOAT32);
+ * </PRE>
+ * WARNING: THIS DOES NOT TAKE INTO ACCOUNT ANY PADDING AS DONE UNTIL HYDRO
+ * For simple usual cases, the overloaded setPointCloud2FieldsByString is what you want.
+ */
+inline void PointCloud2Modifier::setPointCloud2Fields(int n_fields, ...)
+{
+  cloud_msg_.fields.clear();
+  cloud_msg_.fields.reserve(n_fields);
+  va_list vl;
+  va_start(vl, n_fields);
+  int offset = 0;
+  for (int i = 0; i < n_fields; ++i) {
+    // Create the corresponding PointField
+    std::string name(va_arg(vl, char*));
+    int count(va_arg(vl, int));
+    int datatype(va_arg(vl, int));
+    offset = addPointField(cloud_msg_, name, count, datatype, offset);
+  }
+  va_end(vl);
+
+  // Resize the point cloud accordingly
+  cloud_msg_.point_step = offset;
+  cloud_msg_.row_step = cloud_msg_.width * cloud_msg_.point_step;
+  cloud_msg_.data.resize(cloud_msg_.height * cloud_msg_.row_step);
+}
+
+/**
+ * @brief Function setting some fields in a PointCloud and adjusting the
+ *        internals of the PointCloud2
+ * @param n_fields the number of fields to add. The fields are given as
+ *        strings: "xyz" (3 floats), "rgb" (3 uchar stacked in a float),
+ *        "rgba" (4 uchar stacked in a float)
+ * @return void
+ *
+ * WARNING: THIS FUNCTION DOES ADD ANY NECESSARY PADDING TRANSPARENTLY
+ */
+inline void PointCloud2Modifier::setPointCloud2FieldsByString(int n_fields, ...)
+{
+  cloud_msg_.fields.clear();
+  cloud_msg_.fields.reserve(n_fields);
+  va_list vl;
+  va_start(vl, n_fields);
+  int offset = 0;
+  for (int i = 0; i < n_fields; ++i) {
+    // Create the corresponding PointFields
+    std::string
+    field_name = std::string(va_arg(vl, char*));
+    if (field_name == "xyz") {
+      sensor_msgs::PointField point_field;
+      // Do x, y and z
+      offset = addPointField(cloud_msg_, "x", 1, sensor_msgs::PointField::FLOAT32, offset);
+      offset = addPointField(cloud_msg_, "y", 1, sensor_msgs::PointField::FLOAT32, offset);
+      offset = addPointField(cloud_msg_, "z", 1, sensor_msgs::PointField::FLOAT32, offset);
+      offset += sizeOfPointField(sensor_msgs::PointField::FLOAT32);
+    } else
+      if ((field_name == "rgb") || (field_name == "rgba")) {
+        offset = addPointField(cloud_msg_, field_name, 1, sensor_msgs::PointField::FLOAT32, offset);
+        offset += 3 * sizeOfPointField(sensor_msgs::PointField::FLOAT32);
+      } else
+        throw std::runtime_error("Field " + field_name + " does not exist");
+  }
+  va_end(vl);
+
+  // Resize the point cloud accordingly
+  cloud_msg_.point_step = offset;
+  cloud_msg_.row_step = cloud_msg_.width * cloud_msg_.point_step;
+  cloud_msg_.data.resize(cloud_msg_.height * cloud_msg_.row_step);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace impl
+{
+
+/**
+ */
+template<typename T, typename TT, typename U, typename C, template <typename> class V>
+PointCloud2IteratorBase<T, TT, U, C, V>::PointCloud2IteratorBase() : data_char_(0), data_(0), data_end_(0)
+{
+}
+
+/**
+ * @param cloud_msg_ The PointCloud2 to iterate upon
+ * @param field_name The field to iterate upon
+ */
+template<typename T, typename TT, typename U, typename C, template <typename> class V>
+PointCloud2IteratorBase<T, TT, U, C, V>::PointCloud2IteratorBase(C &cloud_msg, const std::string &field_name)
+{
+  int offset = set_field(cloud_msg, field_name);
+
+  data_char_ = &(cloud_msg.data.front()) + offset;
+  data_ = reinterpret_cast<TT*>(data_char_);
+  data_end_ = reinterpret_cast<TT*>(&(cloud_msg.data.back()) + 1 + offset);
+}
+
+/** Assignment operator
+ * @param iter the iterator to copy data from
+ * @return a reference to *this
+ */
+template<typename T, typename TT, typename U, typename C, template <typename> class V>
+V<T>& PointCloud2IteratorBase<T, TT, U, C, V>::operator =(const V<T> &iter)
+{
+  if (this != &iter)
+  {
+    point_step_ = iter.point_step_;
+    data_char_ = iter.data_char_;
+    data_ = iter.data_;
+    data_end_ = iter.data_end_;
+    is_bigendian_ = iter.is_bigendian_;
+  }
+
+  return *this;
+}
+
+/** Access the i th element starting at the current pointer (useful when a field has several elements of the same
+ * type)
+ * @param i
+ * @return a reference to the i^th value from the current position
+ */
+template<typename T, typename TT, typename U, typename C, template <typename> class V>
+TT& PointCloud2IteratorBase<T, TT, U, C, V>::operator [](size_t i) const
+{
+  return *(data_ + i);
+}
+
+/** Dereference the iterator. Equivalent to accessing it through [0]
+ * @return the value to which the iterator is pointing
+ */
+template<typename T, typename TT, typename U, typename C, template <typename> class V>
+TT& PointCloud2IteratorBase<T, TT, U, C, V>::operator *() const
+{
+  return *data_;
+}
+
+/** Increase the iterator to the next element
+ * @return a reference to the updated iterator
+ */
+template<typename T, typename TT, typename U, typename C, template <typename> class V>
+V<T>& PointCloud2IteratorBase<T, TT, U, C, V>::operator ++()
+{
+  data_char_ += point_step_;
+  data_ = reinterpret_cast<TT*>(data_char_);
+  return *static_cast<V<T>*>(this);
+}
+
+/** Basic pointer addition
+ * @param i the amount to increase the iterator by
+ * @return an iterator with an increased position
+ */
+template<typename T, typename TT, typename U, typename C, template <typename> class V>
+V<T> PointCloud2IteratorBase<T, TT, U, C, V>::operator +(int i)
+{
+  V<T> res = *static_cast<V<T>*>(this);
+
+  res.data_char_ += i*point_step_;
+  res.data_ = reinterpret_cast<TT*>(res.data_char_);
+
+  return res;
+}
+
+/** Increase the iterator by a certain amount
+ * @return a reference to the updated iterator
+ */
+template<typename T, typename TT, typename U, typename C, template <typename> class V>
+V<T>& PointCloud2IteratorBase<T, TT, U, C, V>::operator +=(int i)
+{
+  data_char_ += i*point_step_;
+  data_ = reinterpret_cast<TT*>(data_char_);
+  return *static_cast<V<T>*>(this);
+}
+
+/** Compare to another iterator
+ * @return whether the current iterator points to a different address than the other one
+ */
+template<typename T, typename TT, typename U, typename C, template <typename> class V>
+bool PointCloud2IteratorBase<T, TT, U, C, V>::operator !=(const V<T>& iter) const
+{
+  return iter.data_ != data_;
+}
+
+/** Return the end iterator
+ * @return the end iterator (useful when performing normal iterator processing with ++)
+ */
+template<typename T, typename TT, typename U, typename C, template <typename> class V>
+V<T> PointCloud2IteratorBase<T, TT, U, C, V>::end() const
+{
+  V<T> res = *static_cast<const V<T>*>(this);
+  res.data_ = data_end_;
+  return res;
+}
+
+/** Common code to set the field of the PointCloud2
+  * @param cloud_msg the PointCloud2 to modify
+  * @param field_name the name of the field to iterate upon
+  * @return the offset at which the field is found
+  */
+template<typename T, typename TT, typename U, typename C, template <typename> class V>
+int PointCloud2IteratorBase<T, TT, U, C, V>::set_field(const sensor_msgs::PointCloud2 &cloud_msg, const std::string &field_name)
+{
+  is_bigendian_ = cloud_msg.is_bigendian;
+  point_step_ = cloud_msg.point_step;
+  // make sure the channel is valid
+  std::vector<sensor_msgs::PointField>::const_iterator field_iter = cloud_msg.fields.begin(), field_end =
+      cloud_msg.fields.end();
+  while ((field_iter != field_end) && (field_iter->name != field_name))
+    ++field_iter;
+
+  if (field_iter == field_end) {
+    // Handle the special case of r,g,b,a (we assume they are understood as the channels of an rgb or rgba field)
+    if ((field_name == "r") || (field_name == "g") || (field_name == "b") || (field_name == "a"))
+    {
+      // Check that rgb or rgba is present
+      field_iter = cloud_msg.fields.begin();
+      while ((field_iter != field_end) && (field_iter->name != "rgb") && (field_iter->name != "rgba"))
+        ++field_iter;
+      if (field_iter == field_end)
+        throw std::runtime_error("Field " + field_name + " does not exist");
+      if (field_name == "r")
+      {
+        if (is_bigendian_)
+          return field_iter->offset + 1;
+        else
+          return field_iter->offset + 2;
+      }
+      if (field_name == "g")
+      {
+        if (is_bigendian_)
+          return field_iter->offset + 2;
+        else
+          return field_iter->offset + 1;
+      }
+      if (field_name == "b")
+      {
+        if (is_bigendian_)
+          return field_iter->offset + 3;
+        else
+          return field_iter->offset + 0;
+      }
+      if (field_name == "a")
+      {
+        if (is_bigendian_)
+          return field_iter->offset + 0;
+        else
+          return field_iter->offset + 3;
+      }
+    } else
+      throw std::runtime_error("Field " + field_name + " does not exist");
+  }
+
+  return field_iter->offset;
+}
+
+}
+}
+
+#endif// SENSOR_MSGS_IMPL_POINT_CLOUD_ITERATOR_H

thirdparty/ros/include/sensor_msgs/point_cloud2_iterator.h

@@ -0,0 +1,302 @@
+/*
+ * Software License Agreement (BSD License)
+ *
+ *  Copyright (c) 2013, Open Source Robotics Foundation
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of Open Source Robotics Foundation nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SENSOR_MSGS_POINT_CLOUD2_ITERATOR_H
+#define SENSOR_MSGS_POINT_CLOUD2_ITERATOR_H
+
+#include <sensor_msgs/PointCloud2.h>
+#include <cstdarg>
+#include <string>
+#include <vector>
+
+/**
+ * \brief Tools for manipulating sensor_msgs
+ *
+ * This file provides two sets of utilities to modify and parse PointCloud2
+ * The first set allows you to conveniently set the fields by hand:
+ * <PRE>
+ *   #include <sensor_msgs/point_cloud_iterator.h>
+ *   // Create a PointCloud2
+ *   sensor_msgs::PointCloud2 cloud_msg;
+ *   // Fill some internals of the PoinCloud2 like the header/width/height ...
+ *   cloud_msgs.height = 1;  cloud_msgs.width = 4;
+ *   // Set the point fields to xyzrgb and resize the vector with the following command
+ *   // 4 is for the number of added fields. Each come in triplet: the name of the PointField,
+ *   // the number of occurrences of the type in the PointField, the type of the PointField
+ *   sensor_msgs::PointCloud2Modifier modifier(cloud_msg);
+ *   modifier.setPointCloud2Fields(4, "x", 1, sensor_msgs::PointField::FLOAT32,
+ *                                            "y", 1, sensor_msgs::PointField::FLOAT32,
+ *                                            "z", 1, sensor_msgs::PointField::FLOAT32,
+ *                                            "rgb", 1, sensor_msgs::PointField::FLOAT32);
+ *   // For convenience and the xyz, rgb, rgba fields, you can also use the following overloaded function.
+ *   // You have to be aware that the following function does add extra padding for backward compatibility though
+ *   // so it is definitely the solution of choice for PointXYZ and PointXYZRGB
+ *   // 2 is for the number of fields to add
+ *   modifier.setPointCloud2FieldsByString(2, "xyz", "rgb");
+ *   // You can then reserve / resize as usual
+ *   modifier.resize(100);
+ * </PRE>
+ *
+ * The second set allow you to traverse your PointCloud using an iterator:
+ * <PRE>
+ *   // Define some raw data we'll put in the PointCloud2
+ *   float point_data[] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0};
+ *   uint8_t color_data[] = {40, 80, 120, 160, 200, 240, 20, 40, 60, 80, 100, 120};
+ *   // Define the iterators. When doing so, you define the Field you would like to iterate upon and
+ *   // the type of you would like returned: it is not necessary the type of the PointField as sometimes
+ *   // you pack data in another type (e.g. 3 uchar + 1 uchar for RGB are packed in a float)
+ *   sensor_msgs::PointCloud2Iterator<float> iter_x(cloud_msg, "x");
+ *   sensor_msgs::PointCloud2Iterator<float> iter_y(cloud_msg, "y");
+ *   sensor_msgs::PointCloud2Iterator<float> iter_z(cloud_msg, "z");
+ *   // Even though the r,g,b,a fields do not exist (it's usually rgb, rgba), you can create iterators for
+ *   // those: they will handle data packing for you (in little endian RGB is packed as *,R,G,B in a float
+ *   // and RGBA as A,R,G,B)
+ *   sensor_msgs::PointCloud2Iterator<uint8_t> iter_r(cloud_msg, "r");
+ *   sensor_msgs::PointCloud2Iterator<uint8_t> iter_g(cloud_msg, "g");
+ *   sensor_msgs::PointCloud2Iterator<uint8_t> iter_b(cloud_msg, "b");
+ *   // Fill the PointCloud2
+ *   for(size_t i=0; i<n_points; ++i, ++iter_x, ++iter_y, ++iter_z, ++iter_r, ++iter_g, ++iter_b) {
+ *     *iter_x = point_data[3*i+0];
+ *     *iter_y = point_data[3*i+1];
+ *     *iter_z = point_data[3*i+2];
+ *     *iter_r = color_data[3*i+0];
+ *     *iter_g = color_data[3*i+1];
+ *     *iter_b = color_data[3*i+2];
+ *   }
+ * </PRE>
+ */
+
+namespace sensor_msgs
+{
+/**
+ * @brief Enables modifying a sensor_msgs::PointCloud2 like a container
+ */
+class PointCloud2Modifier
+{
+public:
+  /**
+   * @brief Default constructor
+   * @param cloud_msg The sensor_msgs::PointCloud2 to modify
+   */
+  PointCloud2Modifier(PointCloud2& cloud_msg);
+
+  /**
+   * @return the number of T's in the original sensor_msgs::PointCloud2
+   */
+  size_t size() const;
+
+  /**
+   * @param size The number of T's to reserve in the original sensor_msgs::PointCloud2 for
+   */
+  void reserve(size_t size);
+
+  /**
+   * @param size The number of T's to change the size of the original sensor_msgs::PointCloud2 by
+   */
+  void resize(size_t size);
+
+  /**
+   * @brief remove all T's from the original sensor_msgs::PointCloud2
+   */
+  void clear();
+
+  /**
+   * @brief Function setting some fields in a PointCloud and adjusting the
+   *        internals of the PointCloud2
+   * @param n_fields the number of fields to add. The fields are given as
+   *        triplets: name of the field as char*, number of elements in the
+   *        field, the datatype of the elements in the field
+   *
+   * E.g, you create your PointCloud2 message with XYZ/RGB as follows:
+   * <PRE>
+   *   setPointCloud2Fields(cloud_msg, 4, "x", 1, sensor_msgs::PointField::FLOAT32,
+   *                                              "y", 1, sensor_msgs::PointField::FLOAT32,
+   *                                              "z", 1, sensor_msgs::PointField::FLOAT32,
+   *                                              "rgb", 1, sensor_msgs::PointField::FLOAT32);
+   * </PRE>
+   * WARNING: THIS DOES NOT TAKE INTO ACCOUNT ANY PADDING AS DONE UNTIL HYDRO
+   * For simple usual cases, the overloaded setPointCloud2FieldsByString is what you want.
+   */
+  void setPointCloud2Fields(int n_fields, ...);
+
+  /**
+   * @brief Function setting some fields in a PointCloud and adjusting the
+   *        internals of the PointCloud2
+   * @param n_fields the number of fields to add. The fields are given as
+   *        strings: "xyz" (3 floats), "rgb" (3 uchar stacked in a float),
+   *        "rgba" (4 uchar stacked in a float)
+   * @return void
+   *
+   * WARNING: THIS FUNCTION DOES ADD ANY NECESSARY PADDING TRANSPARENTLY
+   */
+  void setPointCloud2FieldsByString(int n_fields, ...);
+protected:
+  /** A reference to the original sensor_msgs::PointCloud2 that we read */
+  PointCloud2& cloud_msg_;
+};
+
+namespace impl
+{
+/** Private base class for PointCloud2Iterator and PointCloud2ConstIterator
+ * T is the type of the value on which the child class will be templated
+ * TT is the type of the value to be retrieved (same as T except for constness)
+ * U is the type of the raw data in PointCloud2 (only uchar and const uchar are supported)
+ * C is the type of the pointcloud to intialize from (const or not)
+ * V is the derived class (yop, curiously recurring template pattern)
+ */
+template<typename T, typename TT, typename U, typename C, template <typename> class V>
+class PointCloud2IteratorBase
+{
+public:
+  /**
+   */
+  PointCloud2IteratorBase();
+
+  /**
+   * @param cloud_msg The PointCloud2 to iterate upon
+   * @param field_name The field to iterate upon
+   */
+  PointCloud2IteratorBase(C &cloud_msg, const std::string &field_name);
+
+  /** Assignment operator
+   * @param iter the iterator to copy data from
+   * @return a reference to *this
+   */
+  V<T>& operator =(const V<T>& iter);
+
+  /** Access the i th element starting at the current pointer (useful when a field has several elements of the same
+   * type)
+   * @param i
+   * @return a reference to the i^th value from the current position
+   */
+  TT& operator [](size_t i) const;
+
+  /** Dereference the iterator. Equivalent to accessing it through [0]
+   * @return the value to which the iterator is pointing
+   */
+  TT& operator *() const;
+
+  /** Increase the iterator to the next element
+   * @return a reference to the updated iterator
+   */
+  V<T>& operator ++();
+
+  /** Basic pointer addition
+   * @param i the amount to increase the iterator by
+   * @return an iterator with an increased position
+   */
+  V<T> operator +(int i);
+
+  /** Increase the iterator by a certain amount
+   * @return a reference to the updated iterator
+   */
+  V<T>& operator +=(int i);
+
+  /** Compare to another iterator
+   * @return whether the current iterator points to a different address than the other one
+   */
+  bool operator !=(const V<T>& iter) const;
+
+  /** Return the end iterator
+   * @return the end iterator (useful when performing normal iterator processing with ++)
+   */
+  V<T> end() const;
+
+private:
+  /** Common code to set the field of the PointCloud2
+   * @param cloud_msg the PointCloud2 to modify
+   * @param field_name the name of the field to iterate upon
+   * @return the offset at which the field is found
+   */
+  int set_field(const sensor_msgs::PointCloud2 &cloud_msg, const std::string &field_name);
+
+  /** The "point_step" of the original cloud */
+  int point_step_;
+  /** The raw data  in uchar* where the iterator is */
+  U* data_char_;
+  /** The cast data where the iterator is */
+  TT* data_;
+  /** The end() pointer of the iterator */
+  TT* data_end_;
+  /** Whether the fields are stored as bigendian */
+  bool is_bigendian_;
+};
+}
+
+/**
+ * \brief Class that can iterate over a PointCloud2
+ *
+ * T type of the element being iterated upon
+ * E.g, you create your PointClou2 message as follows:
+ * <PRE>
+ *   setPointCloud2FieldsByString(cloud_msg, 2, "xyz", "rgb");
+ * </PRE>
+ *
+ * For iterating over XYZ, you do :
+ * <PRE>
+ *   sensor_msgs::PointCloud2Iterator<float> iter_x(cloud_msg, "x");
+ * </PRE>
+ * and then access X through iter_x[0] or *iter_x
+ * You could create an iterator for Y and Z too but as they are consecutive,
+ * you can just use iter_x[1] and iter_x[2]
+ *
+ * For iterating over RGB, you do:
+ * <PRE>
+ * sensor_msgs::PointCloud2Iterator<uint8_t> iter_rgb(cloud_msg, "rgb");
+ * </PRE>
+ * and then access R,G,B through  iter_rgb[0], iter_rgb[1], iter_rgb[2]
+ */
+template<typename T>
+class PointCloud2Iterator : public impl::PointCloud2IteratorBase<T, T, unsigned char, sensor_msgs::PointCloud2, PointCloud2Iterator>
+{
+public:
+  PointCloud2Iterator(sensor_msgs::PointCloud2 &cloud_msg, const std::string &field_name) :
+    impl::PointCloud2IteratorBase<T, T, unsigned char, sensor_msgs::PointCloud2, sensor_msgs::PointCloud2Iterator>::PointCloud2IteratorBase(cloud_msg, field_name) {}
+};
+
+/**
+ * \brief Same as a PointCloud2Iterator but for const data
+ */
+template<typename T>
+class PointCloud2ConstIterator : public impl::PointCloud2IteratorBase<T, const T, const unsigned char, const sensor_msgs::PointCloud2, PointCloud2ConstIterator>
+{
+public:
+  PointCloud2ConstIterator(const sensor_msgs::PointCloud2 &cloud_msg, const std::string &field_name) :
+    impl::PointCloud2IteratorBase<T, const T, const unsigned char, const sensor_msgs::PointCloud2, sensor_msgs::PointCloud2ConstIterator>::PointCloud2IteratorBase(cloud_msg, field_name) {}
+};
+}
+
+#include <sensor_msgs/impl/point_cloud2_iterator.h>
+
+#endif// SENSOR_MSGS_POINT_CLOUD2_ITERATOR_H

thirdparty/ros/include/sensor_msgs/point_cloud_conversion.h

@@ -0,0 +1,169 @@
+/*
+ * Software License Agreement (BSD License)
+ *
+ *  Copyright (c) 2010, Willow Garage, Inc.
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of Willow Garage, Inc. nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id$
+ *
+ */
+
+#ifndef SENSOR_MSGS_POINT_CLOUD_CONVERSION_H
+#define SENSOR_MSGS_POINT_CLOUD_CONVERSION_H
+
+#include <sensor_msgs/PointCloud.h>
+#include <sensor_msgs/PointCloud2.h>
+#include <sensor_msgs/point_field_conversion.h>
+
+/** 
+  * \brief Convert between the old (sensor_msgs::PointCloud) and the new (sensor_msgs::PointCloud2) format.
+  * \author Radu Bogdan Rusu
+  */
+namespace sensor_msgs
+{
+  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  /** \brief Get the index of a specified field (i.e., dimension/channel)
+    * \param points the the point cloud message
+    * \param field_name the string defining the field name
+    */
+static inline int getPointCloud2FieldIndex (const sensor_msgs::PointCloud2 &cloud, const std::string &field_name)
+{
+  // Get the index we need
+  for (size_t d = 0; d < cloud.fields.size (); ++d)
+    if (cloud.fields[d].name == field_name)
+      return (d);
+  return (-1);
+}
+
+  ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  /** \brief Convert a sensor_msgs::PointCloud message to a sensor_msgs::PointCloud2 message.
+    * \param input the message in the sensor_msgs::PointCloud format
+    * \param output the resultant message in the sensor_msgs::PointCloud2 format
+    */ 
+static inline bool convertPointCloudToPointCloud2 (const sensor_msgs::PointCloud &input, sensor_msgs::PointCloud2 &output)
+{
+  output.header = input.header;
+  output.width  = input.points.size ();
+  output.height = 1;
+  output.fields.resize (3 + input.channels.size ());
+  // Convert x/y/z to fields
+  output.fields[0].name = "x"; output.fields[1].name = "y"; output.fields[2].name = "z";
+  int offset = 0;
+  // All offsets are *4, as all field data types are float32
+  for (size_t d = 0; d < output.fields.size (); ++d, offset += 4)
+  {
+    output.fields[d].offset = offset;
+    output.fields[d].datatype = sensor_msgs::PointField::FLOAT32;
+    output.fields[d].count  = 1;
+  }
+  output.point_step = offset;
+  output.row_step   = output.point_step * output.width;
+  // Convert the remaining of the channels to fields
+  for (size_t d = 0; d < input.channels.size (); ++d)
+    output.fields[3 + d].name = input.channels[d].name;
+  output.data.resize (input.points.size () * output.point_step);
+  output.is_bigendian = false;  // @todo ?
+  output.is_dense     = false;
+
+  // Copy the data points
+  for (size_t cp = 0; cp < input.points.size (); ++cp)
+  {
+    memcpy (&output.data[cp * output.point_step + output.fields[0].offset], &input.points[cp].x, sizeof (float));
+    memcpy (&output.data[cp * output.point_step + output.fields[1].offset], &input.points[cp].y, sizeof (float));
+    memcpy (&output.data[cp * output.point_step + output.fields[2].offset], &input.points[cp].z, sizeof (float));
+    for (size_t d = 0; d < input.channels.size (); ++d)
+    {
+      if (input.channels[d].values.size() == input.points.size())
+      {
+        memcpy (&output.data[cp * output.point_step + output.fields[3 + d].offset], &input.channels[d].values[cp], sizeof (float));
+      }
+    }
+  }
+  return (true);
+}
+
+  ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  /** \brief Convert a sensor_msgs::PointCloud2 message to a sensor_msgs::PointCloud message.
+    * \param input the message in the sensor_msgs::PointCloud2 format
+    * \param output the resultant message in the sensor_msgs::PointCloud format
+    */ 
+static inline bool convertPointCloud2ToPointCloud (const sensor_msgs::PointCloud2 &input, sensor_msgs::PointCloud &output)
+{
+
+  output.header = input.header;
+  output.points.resize (input.width * input.height);
+  output.channels.resize (input.fields.size () - 3);
+  // Get the x/y/z field offsets
+  int x_idx = getPointCloud2FieldIndex (input, "x");
+  int y_idx = getPointCloud2FieldIndex (input, "y");
+  int z_idx = getPointCloud2FieldIndex (input, "z");
+  if (x_idx == -1 || y_idx == -1 || z_idx == -1)
+  {
+    std::cerr << "x/y/z coordinates not found! Cannot convert to sensor_msgs::PointCloud!" << std::endl;
+    return (false);
+  }
+  int x_offset = input.fields[x_idx].offset;
+  int y_offset = input.fields[y_idx].offset;
+  int z_offset = input.fields[z_idx].offset;
+  uint8_t x_datatype = input.fields[x_idx].datatype;
+  uint8_t y_datatype = input.fields[y_idx].datatype;
+  uint8_t z_datatype = input.fields[z_idx].datatype;
+   
+  // Convert the fields to channels
+  int cur_c = 0;
+  for (size_t d = 0; d < input.fields.size (); ++d)
+  {
+    if ((int)input.fields[d].offset == x_offset || (int)input.fields[d].offset == y_offset || (int)input.fields[d].offset == z_offset)
+      continue;
+    output.channels[cur_c].name = input.fields[d].name;
+    output.channels[cur_c].values.resize (output.points.size ());
+    cur_c++;
+  }
+
+  // Copy the data points
+  for (size_t cp = 0; cp < output.points.size (); ++cp)
+  {
+    // Copy x/y/z
+    output.points[cp].x = sensor_msgs::readPointCloud2BufferValue<float>(&input.data[cp * input.point_step + x_offset], x_datatype);
+    output.points[cp].y = sensor_msgs::readPointCloud2BufferValue<float>(&input.data[cp * input.point_step + y_offset], y_datatype);
+    output.points[cp].z = sensor_msgs::readPointCloud2BufferValue<float>(&input.data[cp * input.point_step + z_offset], z_datatype);
+    // Copy the rest of the data
+    int cur_c = 0;
+    for (size_t d = 0; d < input.fields.size (); ++d)
+    {
+      if ((int)input.fields[d].offset == x_offset || (int)input.fields[d].offset == y_offset || (int)input.fields[d].offset == z_offset)
+        continue;
+      output.channels[cur_c++].values[cp] = sensor_msgs::readPointCloud2BufferValue<float>(&input.data[cp * input.point_step + input.fields[d].offset], input.fields[d].datatype);
+    }
+  }
+  return (true);
+}
+}
+#endif// SENSOR_MSGS_POINT_CLOUD_CONVERSION_H

thirdparty/ros/include/sensor_msgs/point_field_conversion.h

@@ -0,0 +1,180 @@
+/*
+ * Software License Agreement (BSD License)
+ *
+ * Robot Operating System code by the University of Osnabrück
+ * Copyright (c) 2015, University of Osnabrück
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   1. Redistributions of source code must retain the above 
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer.
+ *
+ *   2. Redistributions in binary form must reproduce the above 
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *
+ *   3. Neither the name of the copyright holder nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *
+ *
+ * point_field_conversion.h
+ *
+ * Created on: 16.07.2015
+ *  Authors: Sebastian Pütz <spuetz@uni-osnabrueck.de>
+ */
+
+#ifndef SENSOR_MSGS_POINT_FIELD_CONVERSION_H
+#define SENSOR_MSGS_POINT_FIELD_CONVERSION_H
+
+/** 
+  * \brief  This file provides a type to enum mapping for the different
+  *         PointField types and methods to read and write in 
+  *         a PointCloud2 buffer for the different PointField types.
+  * \author Sebastian Pütz
+  */
+namespace sensor_msgs{
+  /*!
+   * \Enum to type mapping.
+   */
+  template<int> struct pointFieldTypeAsType {};
+  template<> struct pointFieldTypeAsType<sensor_msgs::PointField::INT8>    { typedef int8_t   type; };
+  template<> struct pointFieldTypeAsType<sensor_msgs::PointField::UINT8>   { typedef uint8_t  type; };
+  template<> struct pointFieldTypeAsType<sensor_msgs::PointField::INT16>   { typedef int16_t  type; };
+  template<> struct pointFieldTypeAsType<sensor_msgs::PointField::UINT16>  { typedef uint16_t type; };
+  template<> struct pointFieldTypeAsType<sensor_msgs::PointField::INT32>   { typedef int32_t  type; };
+  template<> struct pointFieldTypeAsType<sensor_msgs::PointField::UINT32>  { typedef uint32_t type; };
+  template<> struct pointFieldTypeAsType<sensor_msgs::PointField::FLOAT32> { typedef float    type; };
+  template<> struct pointFieldTypeAsType<sensor_msgs::PointField::FLOAT64> { typedef double   type; };
+  
+  /*!
+   * \Type to enum mapping.
+   */
+  template<typename T> struct typeAsPointFieldType {};
+  template<> struct typeAsPointFieldType<int8_t>   { static const uint8_t value = sensor_msgs::PointField::INT8;    };
+  template<> struct typeAsPointFieldType<uint8_t>  { static const uint8_t value = sensor_msgs::PointField::UINT8;   };
+  template<> struct typeAsPointFieldType<int16_t>  { static const uint8_t value = sensor_msgs::PointField::INT16;   };
+  template<> struct typeAsPointFieldType<uint16_t> { static const uint8_t value = sensor_msgs::PointField::UINT16;  };
+  template<> struct typeAsPointFieldType<int32_t>  { static const uint8_t value = sensor_msgs::PointField::INT32;   };
+  template<> struct typeAsPointFieldType<uint32_t> { static const uint8_t value = sensor_msgs::PointField::UINT32;  };
+  template<> struct typeAsPointFieldType<float>    { static const uint8_t value = sensor_msgs::PointField::FLOAT32; };
+  template<> struct typeAsPointFieldType<double>   { static const uint8_t value = sensor_msgs::PointField::FLOAT64; };
+ 
+  /*!
+   * \Converts a value at the given pointer position, interpreted as the datatype
+   *  specified by the given template argument point_field_type, to the given
+   *  template type T and returns it.
+   * \param data_ptr            pointer into the point cloud 2 buffer
+   * \tparam point_field_type   sensor_msgs::PointField datatype value
+   * \tparam T                  return type
+   */
+  template<int point_field_type, typename T>
+    inline T readPointCloud2BufferValue(const unsigned char* data_ptr){
+      typedef typename pointFieldTypeAsType<point_field_type>::type type;
+      return static_cast<T>(*(reinterpret_cast<type const *>(data_ptr)));
+    }
+  
+  /*!
+   * \Converts a value at the given pointer position interpreted as the datatype
+   *  specified by the given datatype parameter to the given template type and returns it.
+   * \param data_ptr    pointer into the point cloud 2 buffer
+   * \param datatype    sensor_msgs::PointField datatype value
+   * \tparam T          return type
+   */
+  template<typename T>
+    inline T readPointCloud2BufferValue(const unsigned char* data_ptr, const unsigned char datatype){
+      switch(datatype){
+        case sensor_msgs::PointField::INT8:
+          return readPointCloud2BufferValue<sensor_msgs::PointField::INT8, T>(data_ptr);
+        case sensor_msgs::PointField::UINT8:
+          return readPointCloud2BufferValue<sensor_msgs::PointField::UINT8, T>(data_ptr);
+        case sensor_msgs::PointField::INT16:
+          return readPointCloud2BufferValue<sensor_msgs::PointField::INT16, T>(data_ptr);
+        case sensor_msgs::PointField::UINT16:
+          return readPointCloud2BufferValue<sensor_msgs::PointField::UINT16, T>(data_ptr);
+        case sensor_msgs::PointField::INT32:
+          return readPointCloud2BufferValue<sensor_msgs::PointField::INT32, T>(data_ptr);
+        case sensor_msgs::PointField::UINT32:
+          return readPointCloud2BufferValue<sensor_msgs::PointField::UINT32, T>(data_ptr);
+        case sensor_msgs::PointField::FLOAT32:
+          return readPointCloud2BufferValue<sensor_msgs::PointField::FLOAT32, T>(data_ptr);
+        case sensor_msgs::PointField::FLOAT64:
+          return readPointCloud2BufferValue<sensor_msgs::PointField::FLOAT64, T>(data_ptr);
+      }
+      // This should never be reached, but return statement added to avoid compiler warning. (#84)
+      return T();
+    }
+
+  /*!
+   * \Inserts a given value at the given point position interpreted as the datatype
+   *  specified by the template argument point_field_type.
+   * \param data_ptr            pointer into the point cloud 2 buffer
+   * \param value               the value to insert
+   * \tparam point_field_type   sensor_msgs::PointField datatype value
+   * \tparam T                  type of the value to insert
+   */
+  template<int point_field_type, typename T>
+    inline void writePointCloud2BufferValue(unsigned char* data_ptr, T value){
+      typedef typename pointFieldTypeAsType<point_field_type>::type type;
+      *(reinterpret_cast<type*>(data_ptr)) = static_cast<type>(value);
+    }
+
+  /*!
+   * \Inserts a given value at the given point position interpreted as the datatype
+   *  specified by the given datatype parameter.
+   * \param data_ptr    pointer into the point cloud 2 buffer
+   * \param datatype    sensor_msgs::PointField datatype value
+   * \param value       the value to insert
+   * \tparam T          type of the value to insert
+   */
+  template<typename T>
+    inline void writePointCloud2BufferValue(unsigned char* data_ptr, const unsigned char datatype, T value){
+      switch(datatype){
+        case sensor_msgs::PointField::INT8:
+          writePointCloud2BufferValue<sensor_msgs::PointField::INT8, T>(data_ptr, value);
+          break;
+        case sensor_msgs::PointField::UINT8:
+          writePointCloud2BufferValue<sensor_msgs::PointField::UINT8, T>(data_ptr, value);
+          break;
+        case sensor_msgs::PointField::INT16:
+          writePointCloud2BufferValue<sensor_msgs::PointField::INT16, T>(data_ptr, value);
+          break;
+        case sensor_msgs::PointField::UINT16:
+          writePointCloud2BufferValue<sensor_msgs::PointField::UINT16, T>(data_ptr, value);
+          break;
+        case sensor_msgs::PointField::INT32:
+          writePointCloud2BufferValue<sensor_msgs::PointField::INT32, T>(data_ptr, value);
+          break;
+        case sensor_msgs::PointField::UINT32:
+          writePointCloud2BufferValue<sensor_msgs::PointField::UINT32, T>(data_ptr, value);
+          break;
+        case sensor_msgs::PointField::FLOAT32:
+          writePointCloud2BufferValue<sensor_msgs::PointField::FLOAT32, T>(data_ptr, value);
+          break;
+        case sensor_msgs::PointField::FLOAT64:
+          writePointCloud2BufferValue<sensor_msgs::PointField::FLOAT64, T>(data_ptr, value);
+          break;
+      }
+    }
+}
+
+#endif /* point_field_conversion.h */