update

.gitignore

@@ -0,0 +1,2 @@
+# Bỏ qua thư mục build/
+build/

CMakeLists.txt

@@ -0,0 +1,27 @@
+cmake_minimum_required(VERSION 3.10)
+project(common_msgs)
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+
+if (NOT TARGET robot_std_msgs)
+    add_subdirectory(robot_std_msgs)
+endif()
+if (NOT TARGET robot_geometry_msgs)
+    add_subdirectory(robot_geometry_msgs)
+endif()
+if (NOT TARGET robot_sensor_msgs)
+    add_subdirectory(robot_sensor_msgs)
+endif()
+if (NOT TARGET robot_nav_msgs)
+    add_subdirectory(robot_nav_msgs)
+endif()
+if(NOT TARGET robot_map_msgs)
+    add_subdirectory(robot_map_msgs)
+endif()
+if(NOT TARGET robot_visualization_msgs)
+    add_subdirectory(robot_visualization_msgs)
+endif()
+if(NOT TARGET robot_protocol_msgs)
+    add_subdirectory(robot_protocol_msgs)
+endif()

geometry_msgs/CMakeLists.txt

@@ -1,20 +0,0 @@
-cmake_minimum_required(VERSION 3.10)
-project(geometry_msgs)
-
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-if (NOT TARGET std_msgs)
-    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../std_msgs ${CMAKE_BINARY_DIR}/std_msgs_build)
-endif()
-
-# Thư viện header-only
-add_library(geometry_msgs INTERFACE)
-
-# Include path tới thư mục chứa file header
-target_include_directories(geometry_msgs INTERFACE
-  ${CMAKE_CURRENT_SOURCE_DIR}/include
-)
-
-# Liên kết với std_msgs nếu bạn có file Header.h trong include/std_msgs/
-target_link_libraries(geometry_msgs INTERFACE std_msgs)

geometry_msgs/include/geometry_msgs/Accel.h

@@ -1,28 +0,0 @@
-// # This expresses acceleration in free space broken into its linear and angular parts.
-// Vector3  linear
-// Vector3  angular
-
-#ifndef ACCEL_H
-#define ACCEL_H
-
-#include <geometry_msgs/Vector3.h>
-
-namespace geometry_msgs
-{
-
-struct Accel
-{
-    Vector3 linear;
-    Vector3 angular;
-
-    // Constructor mặc định
-    Accel() : linear(), angular() {}
-
-    // Constructor khởi tạo nhanh
-    Accel(const Vector3& linear_, const Vector3& angular_)
-        : linear(linear_), angular(angular_) {}
-};
-
-} // namespace geometry_msgs
-
-#endif // ACCEL_H

geometry_msgs/include/geometry_msgs/AccelStamped.h

@@ -1,24 +0,0 @@
-// # An accel with reference coordinate frame and timestamp
-// Header header
-// Accel accel
-
-#ifndef ACCEL_STAMPED_H
-#define ACCEL_STAMPED_H
-
-#include <std_msgs/Header.h>
-#include <geometry_msgs/Accel.h>
-
-namespace geometry_msgs
-{
-
-struct AccelStamped
-{
-    std_msgs::Header header;
-    Accel accel;
-    // Constructor mặc định
-    AccelStamped() = default;
-};
-
-} // namespace geometry_msgs
-
-#endif // ACCEL_STAMPED_H

geometry_msgs/include/geometry_msgs/AccelWithCovariance.h

@@ -1,31 +0,0 @@
-// # This expresses acceleration in free space with uncertainty.
-
-// Accel accel
-
-// # Row-major representation of the 6x6 covariance matrix
-// # The orientation parameters use a fixed-axis representation.
-// # In order, the parameters are:
-// # (x, y, z, rotation about X axis, rotation about Y axis, rotation about Z axis)
-// float64[36] covariance
-
-#ifndef ACCEL_WITH_COVARIANCE_H
-#define ACCEL_WITH_COVARIANCE_H
-
-#include <array>
-#include <geometry_msgs/Accel.h>
-
-namespace geometry_msgs
-{
-
-struct AccelWithCovariance
-{
-    Accel accel;
-    std::array<double, 36> covariance;
-    // Constructor mặc định
-    AccelWithCovariance() = default;
-};
-
-} // namespace geometry_msgs
-
-#endif // ACCEL_WITH_COVARIANCE_H
-

geometry_msgs/include/geometry_msgs/AccelWithCovarianceStamped.h

@@ -1,24 +0,0 @@
-// # This represents an estimated accel with reference coordinate frame and timestamp.
-// Header header
-// AccelWithCovariance accel
-
-#ifndef ACCEL_WITH_COVARIANCE_STAMPED_H
-#define ACCEL_WITH_COVARIANCE_STAMPED_H
-
-#include <std_msgs/Header.h>
-#include <geometry_msgs/AccelWithCovariance.h>
-
-namespace geometry_msgs
-{
-
-struct AccelWithCovarianceStamped
-{
-    std_msgs::Header header;
-    AccelWithCovariance accel;
-    // Constructor mặc định
-    AccelWithCovarianceStamped() = default;
-};
-
-} // namespace geometry_msgs
-
-#endif // ACCEL_WITH_COVARIANCE_STAMPED_H

geometry_msgs/include/geometry_msgs/Inertia.h

@@ -1,40 +0,0 @@
-// # Mass [kg]
-// float64 m
-
-// # Center of mass [m]
-// geometry_msgs/Vector3 com
-
-// # Inertia Tensor [kg-m^2]
-// #     | ixx ixy ixz |
-// # I = | ixy iyy iyz |
-// #     | ixz iyz izz |
-// float64 ixx
-// float64 ixy
-// float64 ixz
-// float64 iyy
-// float64 iyz
-// float64 izz
-
-#ifndef INERTIA_H
-#define INERTIA_H
-
-#include <geometry_msgs/Vector3.h>
-
-namespace geometry_msgs
-{
-
-struct Inertia
-{
-    double m;
-    Vector3 com;
-    double ixx;
-    double ixy;
-    double ixz;
-    double iyy;
-    double iyz;
-    double izz;
-};
-
-} // namespace geometry_msgs
-
-#endif // INERTIA_H

geometry_msgs/include/geometry_msgs/InertiaStamped.h

@@ -1,23 +0,0 @@
-// Header header
-// Inertia inertia
-
-#ifndef INERTIA_STAMPED_H
-#define INERTIA_STAMPED_H
-
-#include <std_msgs/Header.h>
-#include <geometry_msgs/Inertia.h>
-
-namespace geometry_msgs
-{
-
-struct InertiaStamped
-{
-    std_msgs::Header header;
-    Inertia inertia;
-    // Constructor mặc định
-    InertiaStamped() = default;
-};
-
-} // namespace geometry_msgs
-
-#endif // INERTIA_STAMPED_H

geometry_msgs/include/geometry_msgs/Point.h

@@ -1,26 +0,0 @@
-#ifndef POINT_H
-#define POINT_H
-
-#include <cmath>
-#include <iostream>
-
-namespace geometry_msgs
-{
-
-struct Point
-{
-    double x;
-    double y;
-    double z;
-
-    // Constructor mặc định
-    Point() : x(0.0), y(0.0), z(0.0) {}
-
-    // Constructor khởi tạo nhanh
-    Point(double x_, double y_, double z_ = 0.0)
-        : x(x_), y(y_), z(z_) {}
-};
-
-} // namespace geometry_msgs
-
-#endif // POINT_H

geometry_msgs/include/geometry_msgs/Point32.h

@@ -1,14 +0,0 @@
-#ifndef POINT_32_H
-#define POINT_32_H
-
-namespace geometry_msgs
-{
-struct Point32
-{
-    float x;
-    float y;
-    float z;
-};
-} // namespace geometry_msgs
-
-#endif //POINT_32_H

geometry_msgs/include/geometry_msgs/PointStamped.h

@@ -1,21 +0,0 @@
-// # This represents a Point with reference coordinate frame and timestamp
-// Header header
-// Point point
-#ifndef POINT_STAMPED_H
-#define POINT_STAMPED_H
-#include "std_msgs/Header.h"
-#include "geometry_msgs/Point.h"
-
-namespace geometry_msgs
-{
-    
-struct PointStamped
-{
-    std_msgs::Header header;
-    geometry_msgs::Point point;
-    PointStamped() = default;
-};
-
-} // namespace geometry_msgs
-
-#endif //POINT_STAMPED_H

geometry_msgs/include/geometry_msgs/Polygon.h

@@ -1,16 +0,0 @@
-#ifndef POLYGON_H
-#define POLYGON_H
-#include<vector>
-#include<geometry_msgs/Point32.h>
-
-namespace geometry_msgs
-{
-
-struct Polygon
-{
-    std::vector<geometry_msgs::Point32> points;
-};
-
-} // namespace geometry_msgs
-
-#endif //POLYGON_H

geometry_msgs/include/geometry_msgs/PolygonStamped.h

@@ -1,21 +0,0 @@
-// # This represents a Polygon with reference coordinate frame and timestamp
-// Header header
-// Polygon polygon
-#ifndef POLYGON_STAMPED_H
-#define POLYGON_STAMPED_H
-
-#include<std_msgs/Header.h>
-#include<geometry_msgs/Polygon.h>
-
-namespace geometry_msgs
-{
-
-struct PolygonStamped
-{
-    std_msgs::Header header;
-    Polygon polygon;
-};
-
-} // namespace geometry_msgs
-
-#endif //POLYGON_STAMPED_H

geometry_msgs/include/geometry_msgs/Pose.h

@@ -1,20 +0,0 @@
-#ifndef POSE_H
-#define POSE_H
-
-#include <cmath>
-#include <iostream>
-#include <geometry_msgs/Point.h>
-#include <geometry_msgs/Quaternion.h>
-
-namespace geometry_msgs
-{
-
-struct Pose
-{
-    Point position;
-    Quaternion orientation;
-};
-
-} // namespace geometry_msgs
-
-#endif // POSE_H

geometry_msgs/include/geometry_msgs/Pose2D.h

@@ -1,31 +0,0 @@
-// # Deprecated
-// # Please use the full 3D pose.
-
-// # In general our recommendation is to use a full 3D representation of everything and for 2D specific applications make the appropriate projections into the plane for their calculations but optimally will preserve the 3D information during processing.
-
-// # If we have parallel copies of 2D datatypes every UI and other pipeline will end up needing to have dual interfaces to plot everything. And you will end up with not being able to use 3D tools for 2D use cases even if they're completely valid, as you'd have to reimplement it with different inputs and outputs. It's not particularly hard to plot the 2D pose or compute the yaw error for the Pose message and there are already tools and libraries that can do this for you.
-
-
-// # This expresses a position and orientation on a 2D manifold.
-
-// float64 x
-// float64 y
-// float64 theta
-
-#ifndef POSE2D_H
-#define POSE2D_H
-
-namespace geometry_msgs
-{
-
-struct Pose2D
-{
-    double x;
-    double y;
-    double theta;
-};
-
-} // namespace geometry_msgs
-
-#endif // POSE2D_H
-

geometry_msgs/include/geometry_msgs/PoseArray.h

@@ -1,28 +0,0 @@
-// # An array of poses with a header for global reference.
-
-// Header header
-
-// Pose[] poses
-#ifndef POSE_ARRAY_H
-#define POSE_ARRAY_H
-
-#include <vector>
-#include <std_msgs/Header.h>
-#include <geometry_msgs/Pose.h>
-
-
-
-namespace geometry_msgs
-{
-
-struct PoseArray
-{
-    std_msgs::Header header;
-    std::vector<Pose> poses;
-
-    PoseArray() = default;
-};
-
-} // namespace geometry_msgs
-
-#endif // POSE_ARRAY_H

geometry_msgs/include/geometry_msgs/PoseStamped.h

@@ -1,25 +0,0 @@
-// # A Pose with reference coordinate frame and timestamp
-// Header header
-// Pose pose
-#ifndef POSE_STAMPED_H
-#define POSE_STAMPED_H
-
-#include <std_msgs/Header.h>
-#include <geometry_msgs/Pose.h>
-
-
-
-namespace geometry_msgs
-{
-
-struct PoseStamped
-{
-    std_msgs::Header header;
-    Pose pose;
-
-    PoseStamped() = default;
-};
-
-} // namespace geometry_msgs
-
-#endif // POSE_STAMPED_H

geometry_msgs/include/geometry_msgs/PoseWithCovariance.h

@@ -1,31 +0,0 @@
-// # This represents a pose in free space with uncertainty.
-
-// Pose pose
-
-// # Row-major representation of the 6x6 covariance matrix
-// # The orientation parameters use a fixed-axis representation.
-// # In order, the parameters are:
-// # (x, y, z, rotation about X axis, rotation about Y axis, rotation about Z axis)
-// float64[36] covariance
-
-#ifndef POSE_WITH_COVARIANCE_H
-#define POSE_WITH_COVARIANCE_H
-
-#include <array>
-#include <geometry_msgs/Pose.h>
-
-
-namespace geometry_msgs
-{
-
-struct PoseWithCovariance
-{
-    Pose pose;
-    std::array<double, 36> covariance;
-
-    PoseWithCovariance() = default;
-};
-
-} // namespace geometry_msgs
-
-#endif // POSE_WITH_COVARIANCE_H

geometry_msgs/include/geometry_msgs/PoseWithCovarianceStamped.h

@@ -1,27 +0,0 @@
-// # This expresses an estimated pose with a reference coordinate frame and timestamp
-
-// Header header
-// PoseWithCovariance pose
-
-#ifndef POSE_WITH_COVARIANCE_STAMPED_H
-#define POSE_WITH_COVARIANCE_STAMPED_H
-
-#include <std_msgs/Header.h>
-#include <geometry_msgs/PoseWithCovariance.h>
-
-
-
-namespace geometry_msgs
-{
-
-struct PoseWithCovarianceStamped
-{
-    std_msgs::Header header;
-    PoseWithCovariance pose;
-
-    PoseWithCovarianceStamped() = default;
-};
-
-} // namespace geometry_msgs
-
-#endif // POSE_WITH_COVARIANCE_STAMPED_H

geometry_msgs/include/geometry_msgs/Quaternion.h

@@ -1,24 +0,0 @@
-#ifndef QUATERNION_H
-#define QUATERNION_H
-
-namespace geometry_msgs
-{
-
-struct Quaternion
-{
-    double x;
-    double y;
-    double z;
-    double w;
-
-    // Constructor mặc định
-    Quaternion() : x(0.0), y(0.0), z(0.0), w(0.0) {}
-
-    // Constructor khởi tạo nhanh
-    Quaternion(double x_, double y_, double z_, double w_)
-        : x(x_), y(y_), z(z_), w(w_) {}
-};
-
-} // namespace geometry_msgs
-
-#endif // QUATERNION_H

geometry_msgs/include/geometry_msgs/QuaternionStamped.h

@@ -1,25 +0,0 @@
-// # This represents an orientation with reference coordinate frame and timestamp.
-
-// Header header
-// Quaternion quaternion
-
-#ifndef QUATERNION_STAMPED_H
-#define QUATERNION_STAMPED_H
-
-#include <std_msgs/Header.h>
-#include <geometry_msgs/Quaternion.h>
-
-namespace geometry_msgs
-{
-
-struct QuaternionStamped
-{
-    std_msgs::Header header;
-    Quaternion quaternion;
-    // Constructor mặc định
-    QuaternionStamped() = default;
-};
-
-} // namespace geometry_msgs
-
-#endif // QUATERNION_STAMPED_H

geometry_msgs/include/geometry_msgs/Transform.h

@@ -1,18 +0,0 @@
-#ifndef TRANSFORM_H
-#define TRANSFORM_H
-
-#include "geometry_msgs/Vector3.h"
-#include "geometry_msgs/Quaternion.h"
-
-namespace geometry_msgs
-{
-
-struct Transform
-{
-    Vector3 translation;
-    Quaternion rotation;
-};
-
-} // namespace geometry_msgs
-
-#endif // TRANSFORM_H

geometry_msgs/include/geometry_msgs/TransformStamped.h

@@ -1,20 +0,0 @@
-#ifndef TRANSFORM_STAMPED_H
-#define TRANSFORM_STAMPED_H
-
-#include "std_msgs/Header.h"
-#include "geometry_msgs/Transform.h"
-#include <string>
-
-namespace geometry_msgs
-{
-
-struct TransformStamped
-{
-    std_msgs::Header header;
-    std::string child_frame_id;
-    Transform transform;
-};
-
-} // namespace geometry_msgs
-
-#endif // TRANSFORM_STAMPED_H

geometry_msgs/include/geometry_msgs/Twist.h

@@ -1,28 +0,0 @@
-// # This expresses velocity in free space broken into its linear and angular parts.
-// Vector3 linear
-// Vector3 angular
-
-#ifndef TWIST_H
-#define TWIST_H
-
-#include <geometry_msgs/Vector3.h>
-
-namespace geometry_msgs
-{
-
-struct Twist
-{
-    Vector3 linear;
-    Vector3 angular;
-
-    // Constructor mặc định
-    Twist() : linear(), angular() {}
-
-    // Constructor khởi tạo nhanh
-    Twist(const Vector3& linear_, const Vector3& angular_)
-        : linear(linear_), angular(angular_) {}
-};
-
-} // namespace geometry_msgs
-
-#endif // ACCEL_H

geometry_msgs/include/geometry_msgs/TwistStamped.h

@@ -1,24 +0,0 @@
-// # A twist with reference coordinate frame and timestamp
-// Header header
-// Twist twist
-
-#ifndef TWIST_STAMPED_H
-#define TWIST_STAMPED_H
-
-#include <std_msgs/Header.h>
-#include <geometry_msgs/Twist.h>
-
-namespace geometry_msgs
-{
-
-struct TwistStamped
-{
-    std_msgs::Header header;
-    Twist twist;
-    // Constructor mặc định
-    TwistStamped() = default;
-};
-
-} // namespace geometry_msgs
-
-#endif // TWIST_STAMPED_H

geometry_msgs/include/geometry_msgs/TwistWithCovariance.h

@@ -1,31 +0,0 @@
-// # This expresses velocity in free space with uncertainty.
-
-// Twist twist
-
-// # Row-major representation of the 6x6 covariance matrix
-// # The orientation parameters use a fixed-axis representation.
-// # In order, the parameters are:
-// # (x, y, z, rotation about X axis, rotation about Y axis, rotation about Z axis)
-// float64[36] covariance
-
-#ifndef TWIST_WITH_COVARIANCE_H
-#define TWIST_WITH_COVARIANCE_H
-
-#include <array>
-#include <geometry_msgs/Twist.h>
-
-
-namespace geometry_msgs
-{
-
-struct TwistWithCovariance
-{
-    Twist twist;
-    std::array<double, 36> covariance;
-
-    TwistWithCovariance() = default;
-};
-
-} // namespace geometry_msgs
-
-#endif // TWIST_WITH_COVARIANCE_H

geometry_msgs/include/geometry_msgs/TwistWithCovarianceStamped.h

@@ -1,26 +0,0 @@
-// # This represents an estimated twist with reference coordinate frame and timestamp.
-// Header header
-// TwistWithCovariance twist
-
-#ifndef TWIST_WITH_COVARIANCE_STAMPED_H
-#define TWIST_WITH_COVARIANCE_STAMPED_H
-
-#include <std_msgs/Header.h>
-#include <geometry_msgs/PoseWithCovariance.h>
-
-
-
-namespace geometry_msgs
-{
-
-struct TwistWithCovarianceStamped
-{
-    std_msgs::Header header;
-    TwistWithCovariance twist;
-
-    TwistWithCovarianceStamped() = default;
-};
-
-} // namespace geometry_msgs
-
-#endif // TWIST_WITH_COVARIANCE_STAMPED_H

geometry_msgs/include/geometry_msgs/Vector3.h

@@ -1,23 +0,0 @@
-#ifndef VECTOR_3_H
-#define VECTOR_3_H
-
-namespace geometry_msgs
-{
-
-struct Vector3
-{
-    double x;
-    double y;
-    double z;
-
-    // Constructor mặc định
-    Vector3() : x(0.0), y(0.0), z(0.0) {}
-
-    // Constructor khởi tạo nhanh
-    Vector3(double x_, double y_, double z_)
-        : x(x_), y(y_), z(z_) {}
-};
-
-} // namespace geometry_msgs
-
-#endif // VECTOR_3_H

geometry_msgs/include/geometry_msgs/Vector3Stamped.h

@@ -1,24 +0,0 @@
-// # This represents a Vector3 with reference coordinate frame and timestamp
-// Header header
-// Vector3 vector
-
-#ifndef VECTOR_3_STAMPED_H
-#define VECTOR_3_STAMPED_H
-
-#include <std_msgs/Header.h>
-#include <geometry_msgs/Vector3.h>
-
-namespace geometry_msgs
-{
-
-struct Vector3Stamped
-{
-    std_msgs::Header header;
-    Vector3 vector;
-    // Constructor mặc định
-    Vector3Stamped() = default;
-};
-
-} // namespace geometry_msgs
-
-#endif // VECTOR_3_STAMPED_H

geometry_msgs/include/geometry_msgs/Wrench.h

@@ -1,24 +0,0 @@
-// # This represents force in free space, separated into
-// # its linear and angular parts.
-// Vector3  force
-// Vector3  torque
-
-#ifndef WRENCH_H
-#define WRENCH_H
-
-#include <geometry_msgs/Vector3.h>
-
-namespace geometry_msgs
-{
-
-struct Wrench
-{
-    Vector3  force;
-    Vector3  torque;
-    // Constructor mặc định
-    Wrench() = default;
-};
-
-} // namespace geometry_msgs
-
-#endif // WRENCH_H

geometry_msgs/include/geometry_msgs/WrenchStamped.h

@@ -1,24 +0,0 @@
-// # A wrench with reference coordinate frame and timestamp
-// Header header
-// Wrench wrench
-
-#ifndef WRENCH_STAMPED_H
-#define WRENCH_STAMPED_H
-
-#include <std_msgs/Header.h>
-#include <geometry_msgs/Wrench.h>
-
-namespace geometry_msgs
-{
-
-struct WrenchStamped
-{
-    std_msgs::Header header;
-    Wrench wrench;
-    // Constructor mặc định
-    WrenchStamped() = default;
-};
-
-} // namespace geometry_msgs
-
-#endif // WRENCH_STAMPED_H

nav_msgs/CMakeLists.txt

@@ -1,26 +0,0 @@
-cmake_minimum_required(VERSION 3.10)
-project(nav_msgs)
-
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-if (NOT TARGET std_msgs)
-    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../std_msgs ${CMAKE_BINARY_DIR}/std_msgs_build)
-endif()
-if (NOT TARGET geometry_msgs)
-    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../geometry_msgs ${CMAKE_BINARY_DIR}/geometry_msgs_build)
-endif()
-
-# Thư viện header-only
-add_library(nav_msgs INTERFACE)
-
-# Include path tới thư mục chứa file header
-target_include_directories(nav_msgs INTERFACE
-  ${CMAKE_CURRENT_SOURCE_DIR}/include
-)
-
-# Liên kết với std_msgs nếu bạn có file Header.h trong include/std_msgs/
-target_link_libraries(nav_msgs INTERFACE 
-                      std_msgs
-                      geometry_msgs
-                      )

nav_msgs/include/nav_msgs/MapMetaData.h

@@ -1,23 +0,0 @@
-#ifndef MAP_META_DATA_H
-#define MAP_META_DATA_H
-
-#include <cstdint>
-#include <string>
-#include <vector>
-#include "geometry_msgs/Pose.h"
-
-namespace nav_msgs
-{
-
-struct MapMetaData
-{
-double map_load_time;
-float resolution;
-uint32_t width;
-uint32_t height;
-geometry_msgs::Pose origin;
-};
-
-}
-
-#endif //MAP_META_DATA_H

nav_msgs/include/nav_msgs/OccupancyGrid.h

@@ -1,24 +0,0 @@
-#ifndef OCCUPANCY_GRID_H
-#define OCCUPANCY_GRID_H
-
-#include <cstdint>
-#include <string>
-#include <vector>
-#include "std_msgs/Header.h"
-#include <nav_msgs/MapMetaData.h>
-
-namespace nav_msgs
-{
-
-struct OccupancyGrid
-{
-std_msgs::Header header;
-
-MapMetaData info;
-
-std::vector<uint8_t> data;
-};
-
-}
-
-#endif //OCCUPANCY_GRID_H

robot_geometry_msgs/CMakeLists.txt

@@ -0,0 +1,153 @@
+cmake_minimum_required(VERSION 3.0.2)
+project(robot_geometry_msgs VERSION 1.0.0 LANGUAGES CXX)
+
+if(DEFINED CATKIN_DEVEL_PREFIX OR DEFINED CATKIN_TOPLEVEL)
+  set(BUILDING_WITH_CATKIN TRUE)
+  message(STATUS "Building robot_geometry_msgs with Catkin")
+
+else()
+  set(BUILDING_WITH_CATKIN FALSE)
+  message(STATUS "Building robot_geometry_msgs with Standalone CMake")
+endif()
+
+# C++ Standard - must be set before find_package
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+if (NOT BUILDING_WITH_CATKIN)
+
+  # Enable Position Independent Code
+  set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+  # Cấu hình RPATH để tránh cycle trong runtime search path
+  set(CMAKE_BUILD_RPATH_USE_ORIGIN TRUE)
+  set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
+  set(CMAKE_BUILD_RPATH "${CMAKE_BINARY_DIR}")
+
+  set(PACKAGES_DIR  
+    robot_std_msgs
+    robot_time
+  )
+
+else()
+
+# ========================================================
+# Catkin specific configuration
+# ========================================================
+  find_package(catkin REQUIRED COMPONENTS         
+    robot_std_msgs
+    robot_time
+  )
+
+  catkin_package(
+    INCLUDE_DIRS include
+    # LIBRARIES không cần vì đây là header-only library
+    CATKIN_DEPENDS robot_std_msgs  robot_time
+  )
+
+  include_directories(
+    include
+    ${catkin_INCLUDE_DIRS}
+  )
+endif()
+
+# Tìm tất cả header files
+file(GLOB_RECURSE HEADERS "include/robot_geometry_msgs/*.h")
+
+# Tạo INTERFACE library (header-only)
+add_library(${PROJECT_NAME} INTERFACE)
+
+if(BUILDING_WITH_CATKIN)
+  add_dependencies(${PROJECT_NAME} ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})
+
+  # Set include directories
+  target_include_directories(${PROJECT_NAME}
+    INTERFACE 
+      $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+      $<INSTALL_INTERFACE:include>
+  )
+
+  # Link dependencies (header-only, chỉ cần include paths)
+  target_link_libraries(${PROJECT_NAME}
+    INTERFACE
+      ${catkin_LIBRARIES}
+  )
+
+else()
+
+  # Set include directories
+  target_include_directories(${PROJECT_NAME}
+    INTERFACE 
+      $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+      $<INSTALL_INTERFACE:include>
+  )
+
+  # Link dependencies (header-only, chỉ cần include paths)
+  target_link_libraries(${PROJECT_NAME}
+    INTERFACE
+      ${PACKAGES_DIR}
+  )
+
+endif()
+
+# Create alias for backward compatibility
+add_library(geometry_msgs ALIAS ${PROJECT_NAME})
+
+if(BUILDING_WITH_CATKIN)
+  ## Mark libraries for installation
+  ## See http://docs.ros.org/melodic/api/catkin/html/howto/format1/building_libraries.html
+  install(TARGETS ${PROJECT_NAME}
+    ARCHIVE DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
+    LIBRARY DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
+    RUNTIME DESTINATION ${CATKIN_GLOBAL_BIN_DESTINATION}
+  )
+
+  ## Mark cpp header files for installation
+  install(DIRECTORY include/${PROJECT_NAME}/
+    DESTINATION ${CATKIN_PACKAGE_INCLUDE_DESTINATION}
+    FILES_MATCHING PATTERN "*.h"
+    PATTERN ".svn" EXCLUDE
+  )
+
+else()
+
+  install(TARGETS ${PROJECT_NAME}
+    EXPORT ${PROJECT_NAME}-targets
+    ARCHIVE DESTINATION lib
+    LIBRARY DESTINATION lib
+    RUNTIME DESTINATION bin
+  )
+
+  # Export targets
+  install(EXPORT ${PROJECT_NAME}-targets
+    FILE ${PROJECT_NAME}-targets.cmake
+    NAMESPACE ${PROJECT_NAME}::
+    DESTINATION lib/cmake/${PROJECT_NAME}
+  )
+
+  ## Mark cpp header files for installation
+  install(DIRECTORY include/${PROJECT_NAME}/
+    DESTINATION include
+    FILES_MATCHING PATTERN "*.h"
+    PATTERN ".svn" EXCLUDE
+  )
+
+  # Print configuration info
+  message(STATUS "=================================")
+  message(STATUS "Project: ${PROJECT_NAME} (Header-Only)")
+  message(STATUS "Version: ${PROJECT_VERSION}")
+  message(STATUS "C++ Standard: ${CMAKE_CXX_STANDARD}")
+  message(STATUS "Headers found:")
+  foreach(hdr ${HEADERS})
+    message(STATUS "  - ${hdr}")
+  endforeach()
+  message(STATUS "Dependencies: robot_std_msgs, robot_time")
+  message(STATUS "=================================")
+endif()
+
+# # ========================================================
+# # Test executable
+# # ========================================================
+# add_executable(${PROJECT_NAME}_test test/main.cpp)
+# target_link_libraries(${PROJECT_NAME}_test PRIVATE ${PROJECT_NAME})

robot_geometry_msgs/include/robot_geometry_msgs/Accel.h

@@ -0,0 +1,209 @@
+// Generated by gencpp from file robot_geometry_msgs/Accel.msg
+// DO NOT EDIT!
+
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_ACCEL_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_ACCEL_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+#include <robot_geometry_msgs/Vector3.h>
+#include <robot_geometry_msgs/Vector3.h>
+
+namespace robot_geometry_msgs
+{
+template <class ContainerAllocator>
+struct Accel_
+{
+  typedef Accel_<ContainerAllocator> Type;
+
+  Accel_()
+    : linear()
+    , angular()  {
+    }
+  Accel_(const ContainerAllocator& _alloc)
+    : linear(_alloc)
+    , angular(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::robot_geometry_msgs::Vector3_<ContainerAllocator>  _linear_type;
+  _linear_type linear;
+
+   typedef  ::robot_geometry_msgs::Vector3_<ContainerAllocator>  _angular_type;
+  _angular_type angular;
+
+
+
+
+
+  typedef boost::shared_ptr< ::robot_geometry_msgs::Accel_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_geometry_msgs::Accel_<ContainerAllocator> const> ConstPtr;
+
+}; // struct Accel_
+
+typedef ::robot_geometry_msgs::Accel_<std::allocator<void> > Accel;
+
+typedef boost::shared_ptr< ::robot_geometry_msgs::Accel > AccelPtr;
+typedef boost::shared_ptr< ::robot_geometry_msgs::Accel const> AccelConstPtr;
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_geometry_msgs::Accel_<ContainerAllocator1> & lhs, const ::robot_geometry_msgs::Accel_<ContainerAllocator2> & rhs)
+{
+  return lhs.linear == rhs.linear &&
+    lhs.angular == rhs.angular;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_geometry_msgs::Accel_<ContainerAllocator1> & lhs, const ::robot_geometry_msgs::Accel_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace robot_geometry_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::robot_geometry_msgs::Accel_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::robot_geometry_msgs::Accel_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::robot_geometry_msgs::Accel_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::robot_geometry_msgs::Accel_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::robot_geometry_msgs::Accel_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::robot_geometry_msgs::Accel_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::robot_geometry_msgs::Accel_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "9f195f881246fdfa2798d1d3eebca84a";
+  }
+
+  static const char* value(const ::robot_geometry_msgs::Accel_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x9f195f881246fdfaULL;
+  static const uint64_t static_value2 = 0x2798d1d3eebca84aULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::robot_geometry_msgs::Accel_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "robot_geometry_msgs/Accel";
+  }
+
+  static const char* value(const ::robot_geometry_msgs::Accel_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::robot_geometry_msgs::Accel_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# This expresses acceleration in free space broken into its linear and angular parts.\n"
+"Vector3  linear\n"
+"Vector3  angular\n"
+"\n"
+"================================================================================\n"
+"MSG: robot_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"
+"# robot_geometry_msgs/Point message instead.\n"
+"\n"
+"float64 x\n"
+"float64 y\n"
+"float64 z\n"
+;
+  }
+
+  static const char* value(const ::robot_geometry_msgs::Accel_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::robot_geometry_msgs::Accel_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.linear);
+      stream.next(m.angular);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct Accel_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::robot_geometry_msgs::Accel_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::robot_geometry_msgs::Accel_<ContainerAllocator>& v)
+  {
+    if (false || !indent.empty())
+      s << std::endl;
+    s << indent << "linear: ";
+    Printer< ::robot_geometry_msgs::Vector3_<ContainerAllocator> >::stream(s, indent + "  ", v.linear);
+    if (true || !indent.empty())
+      s << std::endl;
+    s << indent << "angular: ";
+    Printer< ::robot_geometry_msgs::Vector3_<ContainerAllocator> >::stream(s, indent + "  ", v.angular);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_ACCEL_H

robot_geometry_msgs/include/robot_geometry_msgs/AccelStamped.h

@@ -0,0 +1,61 @@
+// Generated by gencpp from file robot_geometry_msgs/AccelStamped.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_ACCELSTAMPED_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_ACCELSTAMPED_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+#include <robot_std_msgs/Header.h>
+#include <robot_geometry_msgs/Accel.h>
+
+namespace robot_geometry_msgs
+{
+  template <class ContainerAllocator>
+  struct AccelStamped_
+  {
+    typedef AccelStamped_<ContainerAllocator> Type;
+
+    AccelStamped_()
+        : header(), accel()
+    {
+    }
+    AccelStamped_(const ContainerAllocator &_alloc)
+        : header(_alloc), accel(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::robot_std_msgs::Header_<ContainerAllocator> _header_type;
+    _header_type header;
+
+    typedef ::robot_geometry_msgs::Accel_<ContainerAllocator> _accel_type;
+    _accel_type accel;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::AccelStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::AccelStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct AccelStamped_
+
+  typedef ::robot_geometry_msgs::AccelStamped_<std::allocator<void>> AccelStamped;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::AccelStamped> AccelStampedPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::AccelStamped const> AccelStampedConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::AccelStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::AccelStamped_<ContainerAllocator2> &rhs)
+  {
+    return lhs.header == rhs.header &&
+           lhs.accel == rhs.accel;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::AccelStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::AccelStamped_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_ACCELSTAMPED_H

robot_geometry_msgs/include/robot_geometry_msgs/AccelWithCovariance.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_geometry_msgs/AccelWithCovariance.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCE_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCE_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+#include <boost/array.hpp>
+#include <robot_geometry_msgs/Accel.h>
+
+namespace robot_geometry_msgs
+{
+  template <class ContainerAllocator>
+  struct AccelWithCovariance_
+  {
+    typedef AccelWithCovariance_<ContainerAllocator> Type;
+
+    AccelWithCovariance_()
+        : accel(), covariance()
+    {
+      covariance.assign(0.0);
+    }
+    AccelWithCovariance_(const ContainerAllocator &_alloc)
+        : accel(_alloc), covariance()
+    {
+      (void)_alloc;
+      covariance.assign(0.0);
+    }
+
+    typedef ::robot_geometry_msgs::Accel_<ContainerAllocator> _accel_type;
+    _accel_type accel;
+
+    typedef boost::array<double, 36> _covariance_type;
+    _covariance_type covariance;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::AccelWithCovariance_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::AccelWithCovariance_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct AccelWithCovariance_
+
+  typedef ::robot_geometry_msgs::AccelWithCovariance_<std::allocator<void>> AccelWithCovariance;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::AccelWithCovariance> AccelWithCovariancePtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::AccelWithCovariance const> AccelWithCovarianceConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::AccelWithCovariance_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::AccelWithCovariance_<ContainerAllocator2> &rhs)
+  {
+    return lhs.accel == rhs.accel &&
+           lhs.covariance == rhs.covariance;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::AccelWithCovariance_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::AccelWithCovariance_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCE_H

robot_geometry_msgs/include/robot_geometry_msgs/AccelWithCovarianceStamped.h

@@ -0,0 +1,64 @@
+// Generated by gencpp from file robot_geometry_msgs/AccelWithCovarianceStamped.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCESTAMPED_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCESTAMPED_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_std_msgs/Header.h>
+#include <robot_geometry_msgs/AccelWithCovariance.h>
+
+namespace robot_geometry_msgs
+{
+  template <class ContainerAllocator>
+  struct AccelWithCovarianceStamped_
+  {
+    typedef AccelWithCovarianceStamped_<ContainerAllocator> Type;
+
+    AccelWithCovarianceStamped_()
+        : header(), accel()
+    {
+    }
+    AccelWithCovarianceStamped_(const ContainerAllocator &_alloc)
+        : header(_alloc), accel(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::robot_std_msgs::Header_<ContainerAllocator> _header_type;
+    _header_type header;
+
+    typedef ::robot_geometry_msgs::AccelWithCovariance_<ContainerAllocator> _accel_type;
+    _accel_type accel;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct AccelWithCovarianceStamped_
+
+  typedef ::robot_geometry_msgs::AccelWithCovarianceStamped_<std::allocator<void>> AccelWithCovarianceStamped;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::AccelWithCovarianceStamped> AccelWithCovarianceStampedPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::AccelWithCovarianceStamped const> AccelWithCovarianceStampedConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator2> &rhs)
+  {
+    return lhs.header == rhs.header &&
+           lhs.accel == rhs.accel;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCESTAMPED_H

robot_geometry_msgs/include/robot_geometry_msgs/Inertia.h

@@ -0,0 +1,88 @@
+// Generated by gencpp from file robot_geometry_msgs/Inertia.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_INERTIA_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_INERTIA_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_geometry_msgs/Vector3.h>
+
+namespace robot_geometry_msgs
+{
+  template <class ContainerAllocator>
+  struct Inertia_
+  {
+    typedef Inertia_<ContainerAllocator> Type;
+
+    Inertia_()
+        : m(0.0), com(), ixx(0.0), ixy(0.0), ixz(0.0), iyy(0.0), iyz(0.0), izz(0.0)
+    {
+    }
+    Inertia_(const ContainerAllocator &_alloc)
+        : m(0.0), com(_alloc), ixx(0.0), ixy(0.0), ixz(0.0), iyy(0.0), iyz(0.0), izz(0.0)
+    {
+      (void)_alloc;
+    }
+
+    typedef double _m_type;
+    _m_type m;
+
+    typedef ::robot_geometry_msgs::Vector3_<ContainerAllocator> _com_type;
+    _com_type com;
+
+    typedef double _ixx_type;
+    _ixx_type ixx;
+
+    typedef double _ixy_type;
+    _ixy_type ixy;
+
+    typedef double _ixz_type;
+    _ixz_type ixz;
+
+    typedef double _iyy_type;
+    _iyy_type iyy;
+
+    typedef double _iyz_type;
+    _iyz_type iyz;
+
+    typedef double _izz_type;
+    _izz_type izz;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::Inertia_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::Inertia_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Inertia_
+
+  typedef ::robot_geometry_msgs::Inertia_<std::allocator<void>> Inertia;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::Inertia> InertiaPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::Inertia const> InertiaConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::Inertia_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Inertia_<ContainerAllocator2> &rhs)
+  {
+    return lhs.m == rhs.m &&
+           lhs.com == rhs.com &&
+           lhs.ixx == rhs.ixx &&
+           lhs.ixy == rhs.ixy &&
+           lhs.ixz == rhs.ixz &&
+           lhs.iyy == rhs.iyy &&
+           lhs.iyz == rhs.iyz &&
+           lhs.izz == rhs.izz;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::Inertia_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Inertia_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_INERTIA_H

robot_geometry_msgs/include/robot_geometry_msgs/InertiaStamped.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_geometry_msgs/InertiaStamped.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_INERTIASTAMPED_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_INERTIASTAMPED_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_std_msgs/Header.h>
+#include <robot_geometry_msgs/Inertia.h>
+
+namespace robot_geometry_msgs
+{
+  template <class ContainerAllocator>
+  struct InertiaStamped_
+  {
+    typedef InertiaStamped_<ContainerAllocator> Type;
+
+    InertiaStamped_()
+        : header(), inertia()
+    {
+    }
+    InertiaStamped_(const ContainerAllocator &_alloc)
+        : header(_alloc), inertia(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::robot_std_msgs::Header_<ContainerAllocator> _header_type;
+    _header_type header;
+
+    typedef ::robot_geometry_msgs::Inertia_<ContainerAllocator> _inertia_type;
+    _inertia_type inertia;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::InertiaStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::InertiaStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct InertiaStamped_
+
+  typedef ::robot_geometry_msgs::InertiaStamped_<std::allocator<void>> InertiaStamped;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::InertiaStamped> InertiaStampedPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::InertiaStamped const> InertiaStampedConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::InertiaStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::InertiaStamped_<ContainerAllocator2> &rhs)
+  {
+    return lhs.header == rhs.header &&
+           lhs.inertia == rhs.inertia;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::InertiaStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::InertiaStamped_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_INERTIASTAMPED_H

robot_geometry_msgs/include/robot_geometry_msgs/Point.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_geometry_msgs/Point.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_POINT_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_POINT_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+namespace robot_geometry_msgs
+{
+  template <class ContainerAllocator>
+  struct Point_
+  {
+    typedef Point_<ContainerAllocator> Type;
+
+    Point_()
+        : x(0.0), y(0.0), z(0.0)
+    {
+    }
+    Point_(const ContainerAllocator &_alloc)
+        : x(0.0), y(0.0), z(0.0)
+    {
+      (void)_alloc;
+    }
+
+    typedef double _x_type;
+    _x_type x;
+
+    typedef double _y_type;
+    _y_type y;
+
+    typedef double _z_type;
+    _z_type z;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::Point_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::Point_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Point_
+
+  typedef ::robot_geometry_msgs::Point_<std::allocator<void>> Point;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::Point> PointPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::Point const> PointConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::Point_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Point_<ContainerAllocator2> &rhs)
+  {
+    return lhs.x == rhs.x &&
+           lhs.y == rhs.y &&
+           lhs.z == rhs.z;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::Point_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Point_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_POINT_H

robot_geometry_msgs/include/robot_geometry_msgs/Point32.h

@@ -0,0 +1,66 @@
+// Generated by gencpp from file robot_geometry_msgs/Point32.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_POINT32_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_POINT32_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+namespace robot_geometry_msgs
+{
+  template <class ContainerAllocator>
+  struct Point32_
+  {
+    typedef Point32_<ContainerAllocator> Type;
+
+    Point32_()
+        : x(0.0), y(0.0), z(0.0)
+    {
+    }
+    Point32_(const ContainerAllocator &_alloc)
+        : x(0.0), y(0.0), z(0.0)
+    {
+      (void)_alloc;
+    }
+
+    typedef float _x_type;
+    _x_type x;
+
+    typedef float _y_type;
+    _y_type y;
+
+    typedef float _z_type;
+    _z_type z;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::Point32_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::Point32_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Point32_
+
+  typedef ::robot_geometry_msgs::Point32_<std::allocator<void>> Point32;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::Point32> Point32Ptr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::Point32 const> Point32ConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::Point32_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Point32_<ContainerAllocator2> &rhs)
+  {
+    return lhs.x == rhs.x &&
+           lhs.y == rhs.y &&
+           lhs.z == rhs.z;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::Point32_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Point32_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_POINT32_H

robot_geometry_msgs/include/robot_geometry_msgs/PointStamped.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_geometry_msgs/PointStamped.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_POINTSTAMPED_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_POINTSTAMPED_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_std_msgs/Header.h>
+#include <robot_geometry_msgs/Point.h>
+
+namespace robot_geometry_msgs
+{
+  template <class ContainerAllocator>
+  struct PointStamped_
+  {
+    typedef PointStamped_<ContainerAllocator> Type;
+
+    PointStamped_()
+        : header(), point()
+    {
+    }
+    PointStamped_(const ContainerAllocator &_alloc)
+        : header(_alloc), point(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::robot_std_msgs::Header_<ContainerAllocator> _header_type;
+    _header_type header;
+
+    typedef ::robot_geometry_msgs::Point_<ContainerAllocator> _point_type;
+    _point_type point;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::PointStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::PointStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct PointStamped_
+
+  typedef ::robot_geometry_msgs::PointStamped_<std::allocator<void>> PointStamped;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::PointStamped> PointStampedPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::PointStamped const> PointStampedConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::PointStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::PointStamped_<ContainerAllocator2> &rhs)
+  {
+    return lhs.header == rhs.header &&
+           lhs.point == rhs.point;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::PointStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::PointStamped_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_POINTSTAMPED_H

robot_geometry_msgs/include/robot_geometry_msgs/Polygon.h

@@ -0,0 +1,60 @@
+// Generated by gencpp from file robot_geometry_msgs/Polygon.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_POLYGON_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_POLYGON_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_geometry_msgs/Point32.h>
+
+namespace robot_geometry_msgs
+{
+  template <class ContainerAllocator>
+  struct Polygon_
+  {
+    typedef Polygon_<ContainerAllocator> Type;
+
+    Polygon_()
+        : points()
+    {
+    }
+    Polygon_(const ContainerAllocator &_alloc)
+        : points(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef std::vector<::robot_geometry_msgs::Point32_<ContainerAllocator>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<::robot_geometry_msgs::Point32_<ContainerAllocator>>> _points_type;
+    _points_type points;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::Polygon_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::Polygon_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Polygon_
+
+  typedef ::robot_geometry_msgs::Polygon_<std::allocator<void>> Polygon;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::Polygon> PolygonPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::Polygon const> PolygonConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::Polygon_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Polygon_<ContainerAllocator2> &rhs)
+  {
+    return lhs.points == rhs.points;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::Polygon_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Polygon_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_POLYGON_H

robot_geometry_msgs/include/robot_geometry_msgs/PolygonStamped.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_geometry_msgs/PolygonStamped.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_POLYGONSTAMPED_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_POLYGONSTAMPED_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_std_msgs/Header.h>
+#include <robot_geometry_msgs/Polygon.h>
+
+namespace robot_geometry_msgs
+{
+  template <class ContainerAllocator>
+  struct PolygonStamped_
+  {
+    typedef PolygonStamped_<ContainerAllocator> Type;
+
+    PolygonStamped_()
+        : header(), polygon()
+    {
+    }
+    PolygonStamped_(const ContainerAllocator &_alloc)
+        : header(_alloc), polygon(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::robot_std_msgs::Header_<ContainerAllocator> _header_type;
+    _header_type header;
+
+    typedef ::robot_geometry_msgs::Polygon_<ContainerAllocator> _polygon_type;
+    _polygon_type polygon;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::PolygonStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::PolygonStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct PolygonStamped_
+
+  typedef ::robot_geometry_msgs::PolygonStamped_<std::allocator<void>> PolygonStamped;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::PolygonStamped> PolygonStampedPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::PolygonStamped const> PolygonStampedConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::PolygonStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::PolygonStamped_<ContainerAllocator2> &rhs)
+  {
+    return lhs.header == rhs.header &&
+           lhs.polygon == rhs.polygon;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::PolygonStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::PolygonStamped_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_POLYGONSTAMPED_H

robot_geometry_msgs/include/robot_geometry_msgs/Pose.h

@@ -0,0 +1,64 @@
+// Generated by gencpp from file robot_geometry_msgs/Pose.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_POSE_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_POSE_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_geometry_msgs/Point.h>
+#include <robot_geometry_msgs/Quaternion.h>
+
+namespace robot_geometry_msgs
+{
+  template <class ContainerAllocator>
+  struct Pose_
+  {
+    typedef Pose_<ContainerAllocator> Type;
+
+    Pose_()
+        : position(), orientation()
+    {
+    }
+    Pose_(const ContainerAllocator &_alloc)
+        : position(_alloc), orientation(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::robot_geometry_msgs::Point_<ContainerAllocator> _position_type;
+    _position_type position;
+
+    typedef ::robot_geometry_msgs::Quaternion_<ContainerAllocator> _orientation_type;
+    _orientation_type orientation;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::Pose_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::Pose_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Pose_
+
+  typedef ::robot_geometry_msgs::Pose_<std::allocator<void>> Pose;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::Pose> PosePtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::Pose const> PoseConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::Pose_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Pose_<ContainerAllocator2> &rhs)
+  {
+    return lhs.position == rhs.position &&
+           lhs.orientation == rhs.orientation;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::Pose_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Pose_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_POSE_H

robot_geometry_msgs/include/robot_geometry_msgs/Pose2D.h

@@ -0,0 +1,66 @@
+// Generated by gencpp from file robot_geometry_msgs/Pose2D.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_POSE2D_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_POSE2D_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+namespace robot_geometry_msgs
+{
+  template <class ContainerAllocator>
+  struct Pose2D_
+  {
+    typedef Pose2D_<ContainerAllocator> Type;
+
+    Pose2D_()
+        : x(0.0), y(0.0), theta(0.0)
+    {
+    }
+    Pose2D_(const ContainerAllocator &_alloc)
+        : x(0.0), y(0.0), theta(0.0)
+    {
+      (void)_alloc;
+    }
+
+    typedef double _x_type;
+    _x_type x;
+
+    typedef double _y_type;
+    _y_type y;
+
+    typedef double _theta_type;
+    _theta_type theta;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::Pose2D_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::Pose2D_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Pose2D_
+
+  typedef ::robot_geometry_msgs::Pose2D_<std::allocator<void>> Pose2D;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::Pose2D> Pose2DPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::Pose2D const> Pose2DConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::Pose2D_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Pose2D_<ContainerAllocator2> &rhs)
+  {
+    return lhs.x == rhs.x &&
+           lhs.y == rhs.y &&
+           lhs.theta == rhs.theta;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::Pose2D_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Pose2D_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_POSE2D_H

robot_geometry_msgs/include/robot_geometry_msgs/PoseArray.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_geometry_msgs/PoseArray.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_POSEARRAY_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_POSEARRAY_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_std_msgs/Header.h>
+#include <robot_geometry_msgs/Pose.h>
+
+namespace robot_geometry_msgs
+{
+  template <class ContainerAllocator>
+  struct PoseArray_
+  {
+    typedef PoseArray_<ContainerAllocator> Type;
+
+    PoseArray_()
+        : header(), poses()
+    {
+    }
+    PoseArray_(const ContainerAllocator &_alloc)
+        : header(_alloc), poses(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::robot_std_msgs::Header_<ContainerAllocator> _header_type;
+    _header_type header;
+
+    typedef std::vector<::robot_geometry_msgs::Pose_<ContainerAllocator>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<::robot_geometry_msgs::Pose_<ContainerAllocator>>> _poses_type;
+    _poses_type poses;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::PoseArray_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::PoseArray_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct PoseArray_
+
+  typedef ::robot_geometry_msgs::PoseArray_<std::allocator<void>> PoseArray;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::PoseArray> PoseArrayPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::PoseArray const> PoseArrayConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::PoseArray_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::PoseArray_<ContainerAllocator2> &rhs)
+  {
+    return lhs.header == rhs.header &&
+           lhs.poses == rhs.poses;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::PoseArray_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::PoseArray_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_POSEARRAY_H

robot_geometry_msgs/include/robot_geometry_msgs/PoseStamped.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_geometry_msgs/PoseStamped.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_POSESTAMPED_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_POSESTAMPED_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_std_msgs/Header.h>
+#include <robot_geometry_msgs/Pose.h>
+
+namespace robot_geometry_msgs
+{
+  template <class ContainerAllocator>
+  struct PoseStamped_
+  {
+    typedef PoseStamped_<ContainerAllocator> Type;
+
+    PoseStamped_()
+        : header(), pose()
+    {
+    }
+    PoseStamped_(const ContainerAllocator &_alloc)
+        : header(_alloc), pose(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::robot_std_msgs::Header_<ContainerAllocator> _header_type;
+    _header_type header;
+
+    typedef ::robot_geometry_msgs::Pose_<ContainerAllocator> _pose_type;
+    _pose_type pose;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::PoseStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::PoseStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct PoseStamped_
+
+  typedef ::robot_geometry_msgs::PoseStamped_<std::allocator<void>> PoseStamped;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::PoseStamped> PoseStampedPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::PoseStamped const> PoseStampedConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::PoseStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::PoseStamped_<ContainerAllocator2> &rhs)
+  {
+    return lhs.header == rhs.header &&
+           lhs.pose == rhs.pose;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::PoseStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::PoseStamped_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_POSESTAMPED_H

robot_geometry_msgs/include/robot_geometry_msgs/PoseWithCovariance.h

@@ -0,0 +1,63 @@
+// Generated by gencpp from file robot_geometry_msgs/PoseWithCovariance.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCE_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCE_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+#include <boost/array.hpp>
+#include <robot_geometry_msgs/Pose.h>
+
+namespace robot_geometry_msgs
+{
+  template <class ContainerAllocator>
+  struct PoseWithCovariance_
+  {
+    typedef PoseWithCovariance_<ContainerAllocator> Type;
+
+    PoseWithCovariance_()
+        : pose(), covariance()
+    {
+      covariance.assign(0.0);
+    }
+    PoseWithCovariance_(const ContainerAllocator &_alloc)
+        : pose(_alloc), covariance()
+    {
+      (void)_alloc;
+      covariance.assign(0.0);
+    }
+
+    typedef ::robot_geometry_msgs::Pose_<ContainerAllocator> _pose_type;
+    _pose_type pose;
+
+    typedef boost::array<double, 36> _covariance_type;
+    _covariance_type covariance;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::PoseWithCovariance_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::PoseWithCovariance_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct PoseWithCovariance_
+
+  typedef ::robot_geometry_msgs::PoseWithCovariance_<std::allocator<void>> PoseWithCovariance;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::PoseWithCovariance> PoseWithCovariancePtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::PoseWithCovariance const> PoseWithCovarianceConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::PoseWithCovariance_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::PoseWithCovariance_<ContainerAllocator2> &rhs)
+  {
+    return lhs.pose == rhs.pose &&
+           lhs.covariance == rhs.covariance;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::PoseWithCovariance_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::PoseWithCovariance_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCE_H

robot_geometry_msgs/include/robot_geometry_msgs/PoseWithCovarianceStamped.h

@@ -0,0 +1,62 @@
+// Generated by gencpp from file robot_geometry_msgs/PoseWithCovarianceStamped.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCESTAMPED_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCESTAMPED_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_std_msgs/Header.h>
+#include <robot_geometry_msgs/PoseWithCovariance.h>
+
+namespace robot_geometry_msgs
+{
+  template <class ContainerAllocator>
+  struct PoseWithCovarianceStamped_
+  {
+    typedef PoseWithCovarianceStamped_<ContainerAllocator> Type;
+
+    PoseWithCovarianceStamped_()
+        : header(), pose()
+    {
+    }
+    PoseWithCovarianceStamped_(const ContainerAllocator &_alloc)
+        : header(_alloc), pose(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::robot_std_msgs::Header_<ContainerAllocator> _header_type;
+    _header_type header;
+
+    typedef ::robot_geometry_msgs::PoseWithCovariance_<ContainerAllocator> _pose_type;
+    _pose_type pose;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct PoseWithCovarianceStamped_
+
+  typedef ::robot_geometry_msgs::PoseWithCovarianceStamped_<std::allocator<void>> PoseWithCovarianceStamped;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::PoseWithCovarianceStamped> PoseWithCovarianceStampedPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::PoseWithCovarianceStamped const> PoseWithCovarianceStampedConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator2> &rhs)
+  {
+    return lhs.header == rhs.header &&
+           lhs.pose == rhs.pose;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCESTAMPED_H

robot_geometry_msgs/include/robot_geometry_msgs/Quaternion.h

@@ -0,0 +1,69 @@
+// Generated by gencpp from file robot_geometry_msgs/Quaternion.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_QUATERNION_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_QUATERNION_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+namespace robot_geometry_msgs
+{
+  template <class ContainerAllocator>
+  struct Quaternion_
+  {
+    typedef Quaternion_<ContainerAllocator> Type;
+
+    Quaternion_()
+        : x(0.0), y(0.0), z(0.0), w(0.0)
+    {
+    }
+    Quaternion_(const ContainerAllocator &_alloc)
+        : x(0.0), y(0.0), z(0.0), w(0.0)
+    {
+      (void)_alloc;
+    }
+
+    typedef double _x_type;
+    _x_type x;
+
+    typedef double _y_type;
+    _y_type y;
+
+    typedef double _z_type;
+    _z_type z;
+
+    typedef double _w_type;
+    _w_type w;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::Quaternion_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::Quaternion_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Quaternion_
+
+  typedef ::robot_geometry_msgs::Quaternion_<std::allocator<void>> Quaternion;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::Quaternion> QuaternionPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::Quaternion const> QuaternionConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::Quaternion_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Quaternion_<ContainerAllocator2> &rhs)
+  {
+    return lhs.x == rhs.x &&
+           lhs.y == rhs.y &&
+           lhs.z == rhs.z &&
+           lhs.w == rhs.w;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::Quaternion_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Quaternion_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_QUATERNION_H

robot_geometry_msgs/include/robot_geometry_msgs/QuaternionStamped.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_geometry_msgs/QuaternionStamped.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_QUATERNIONSTAMPED_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_QUATERNIONSTAMPED_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_std_msgs/Header.h>
+#include <robot_geometry_msgs/Quaternion.h>
+
+namespace robot_geometry_msgs
+{
+  template <class ContainerAllocator>
+  struct QuaternionStamped_
+  {
+    typedef QuaternionStamped_<ContainerAllocator> Type;
+
+    QuaternionStamped_()
+        : header(), quaternion()
+    {
+    }
+    QuaternionStamped_(const ContainerAllocator &_alloc)
+        : header(_alloc), quaternion(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::robot_std_msgs::Header_<ContainerAllocator> _header_type;
+    _header_type header;
+
+    typedef ::robot_geometry_msgs::Quaternion_<ContainerAllocator> _quaternion_type;
+    _quaternion_type quaternion;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::QuaternionStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::QuaternionStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct QuaternionStamped_
+
+  typedef ::robot_geometry_msgs::QuaternionStamped_<std::allocator<void>> QuaternionStamped;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::QuaternionStamped> QuaternionStampedPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::QuaternionStamped const> QuaternionStampedConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::QuaternionStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::QuaternionStamped_<ContainerAllocator2> &rhs)
+  {
+    return lhs.header == rhs.header &&
+           lhs.quaternion == rhs.quaternion;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::QuaternionStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::QuaternionStamped_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_QUATERNIONSTAMPED_H

robot_geometry_msgs/include/robot_geometry_msgs/Transform.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_geometry_msgs/Transform.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_TRANSFORM_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_TRANSFORM_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_geometry_msgs/Vector3.h>
+#include <robot_geometry_msgs/Quaternion.h>
+
+namespace robot_geometry_msgs
+{
+  template <class ContainerAllocator>
+  struct Transform_
+  {
+    typedef Transform_<ContainerAllocator> Type;
+
+    Transform_()
+        : translation(), rotation()
+    {
+    }
+    Transform_(const ContainerAllocator &_alloc)
+        : translation(_alloc), rotation(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::robot_geometry_msgs::Vector3_<ContainerAllocator> _translation_type;
+    _translation_type translation;
+
+    typedef ::robot_geometry_msgs::Quaternion_<ContainerAllocator> _rotation_type;
+    _rotation_type rotation;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::Transform_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::Transform_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Transform_
+
+  typedef ::robot_geometry_msgs::Transform_<std::allocator<void>> Transform;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::Transform> TransformPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::Transform const> TransformConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::Transform_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Transform_<ContainerAllocator2> &rhs)
+  {
+    return lhs.translation == rhs.translation &&
+           lhs.rotation == rhs.rotation;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::Transform_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Transform_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_TRANSFORM_H

robot_geometry_msgs/include/robot_geometry_msgs/TransformStamped.h

@@ -0,0 +1,69 @@
+// Generated by gencpp from file robot_geometry_msgs/TransformStamped.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_TRANSFORMSTAMPED_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_TRANSFORMSTAMPED_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_std_msgs/Header.h>
+#include <robot_geometry_msgs/Transform.h>
+
+namespace robot_geometry_msgs
+{
+  template <class ContainerAllocator>
+  struct TransformStamped_
+  {
+    typedef TransformStamped_<ContainerAllocator> Type;
+
+    TransformStamped_()
+        : header(), child_frame_id(), transform()
+    {
+    }
+    TransformStamped_(const ContainerAllocator &_alloc)
+        : header(_alloc), child_frame_id(_alloc), transform(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::robot_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>> _child_frame_id_type;
+    _child_frame_id_type child_frame_id;
+
+    typedef ::robot_geometry_msgs::Transform_<ContainerAllocator> _transform_type;
+    _transform_type transform;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::TransformStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::TransformStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct TransformStamped_
+
+  typedef ::robot_geometry_msgs::TransformStamped_<std::allocator<void>> TransformStamped;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::TransformStamped> TransformStampedPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::TransformStamped const> TransformStampedConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::TransformStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::TransformStamped_<ContainerAllocator2> &rhs)
+  {
+    return lhs.header == rhs.header &&
+           lhs.child_frame_id == rhs.child_frame_id &&
+           lhs.transform == rhs.transform;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::TransformStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::TransformStamped_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_TRANSFORMSTAMPED_H

robot_geometry_msgs/include/robot_geometry_msgs/Twist.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_geometry_msgs/Twist.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_TWIST_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_TWIST_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_geometry_msgs/Vector3.h>
+#include <robot_geometry_msgs/Vector3.h>
+
+namespace robot_geometry_msgs
+{
+  template <class ContainerAllocator>
+  struct Twist_
+  {
+    typedef Twist_<ContainerAllocator> Type;
+
+    Twist_()
+        : linear(), angular()
+    {
+    }
+    Twist_(const ContainerAllocator &_alloc)
+        : linear(_alloc), angular(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::robot_geometry_msgs::Vector3_<ContainerAllocator> _linear_type;
+    _linear_type linear;
+
+    typedef ::robot_geometry_msgs::Vector3_<ContainerAllocator> _angular_type;
+    _angular_type angular;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::Twist_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::Twist_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Twist_
+
+  typedef ::robot_geometry_msgs::Twist_<std::allocator<void>> Twist;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::Twist> TwistPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::Twist const> TwistConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::Twist_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Twist_<ContainerAllocator2> &rhs)
+  {
+    return lhs.linear == rhs.linear &&
+           lhs.angular == rhs.angular;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::Twist_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Twist_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_TWIST_H

robot_geometry_msgs/include/robot_geometry_msgs/TwistStamped.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_geometry_msgs/TwistStamped.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_TWISTSTAMPED_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_TWISTSTAMPED_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_std_msgs/Header.h>
+#include <robot_geometry_msgs/Twist.h>
+
+namespace robot_geometry_msgs
+{
+  template <class ContainerAllocator>
+  struct TwistStamped_
+  {
+    typedef TwistStamped_<ContainerAllocator> Type;
+
+    TwistStamped_()
+        : header(), twist()
+    {
+    }
+    TwistStamped_(const ContainerAllocator &_alloc)
+        : header(_alloc), twist(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::robot_std_msgs::Header_<ContainerAllocator> _header_type;
+    _header_type header;
+
+    typedef ::robot_geometry_msgs::Twist_<ContainerAllocator> _twist_type;
+    _twist_type twist;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::TwistStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::TwistStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct TwistStamped_
+
+  typedef ::robot_geometry_msgs::TwistStamped_<std::allocator<void>> TwistStamped;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::TwistStamped> TwistStampedPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::TwistStamped const> TwistStampedConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::TwistStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::TwistStamped_<ContainerAllocator2> &rhs)
+  {
+    return lhs.header == rhs.header &&
+           lhs.twist == rhs.twist;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::TwistStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::TwistStamped_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_TWISTSTAMPED_H

robot_geometry_msgs/include/robot_geometry_msgs/TwistWithCovariance.h

@@ -0,0 +1,66 @@
+// Generated by gencpp from file robot_geometry_msgs/TwistWithCovariance.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCE_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCE_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+#include <boost/array.hpp>
+#include <robot_geometry_msgs/Twist.h>
+
+namespace robot_geometry_msgs
+{
+  template <class ContainerAllocator>
+  struct TwistWithCovariance_
+  {
+    typedef TwistWithCovariance_<ContainerAllocator> Type;
+
+    TwistWithCovariance_()
+        : twist(), covariance()
+    {
+      covariance.assign(0.0);
+    }
+    TwistWithCovariance_(const ContainerAllocator &_alloc)
+        : twist(_alloc), covariance()
+    {
+      (void)_alloc;
+      covariance.assign(0.0);
+    }
+
+    typedef ::robot_geometry_msgs::Twist_<ContainerAllocator> _twist_type;
+    _twist_type twist;
+
+    typedef boost::array<double, 36> _covariance_type;
+    _covariance_type covariance;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::TwistWithCovariance_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::TwistWithCovariance_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct TwistWithCovariance_
+
+  typedef ::robot_geometry_msgs::TwistWithCovariance_<std::allocator<void>> TwistWithCovariance;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::TwistWithCovariance> TwistWithCovariancePtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::TwistWithCovariance const> TwistWithCovarianceConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::TwistWithCovariance_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::TwistWithCovariance_<ContainerAllocator2> &rhs)
+  {
+    return lhs.twist == rhs.twist &&
+           lhs.covariance == rhs.covariance;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::TwistWithCovariance_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::TwistWithCovariance_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCE_H

robot_geometry_msgs/include/robot_geometry_msgs/TwistWithCovarianceStamped.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_geometry_msgs/TwistWithCovarianceStamped.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCESTAMPED_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCESTAMPED_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_std_msgs/Header.h>
+#include <robot_geometry_msgs/TwistWithCovariance.h>
+
+namespace robot_geometry_msgs
+{
+  template <class ContainerAllocator>
+  struct TwistWithCovarianceStamped_
+  {
+    typedef TwistWithCovarianceStamped_<ContainerAllocator> Type;
+
+    TwistWithCovarianceStamped_()
+        : header(), twist()
+    {
+    }
+    TwistWithCovarianceStamped_(const ContainerAllocator &_alloc)
+        : header(_alloc), twist(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::robot_std_msgs::Header_<ContainerAllocator> _header_type;
+    _header_type header;
+
+    typedef ::robot_geometry_msgs::TwistWithCovariance_<ContainerAllocator> _twist_type;
+    _twist_type twist;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct TwistWithCovarianceStamped_
+
+  typedef ::robot_geometry_msgs::TwistWithCovarianceStamped_<std::allocator<void>> TwistWithCovarianceStamped;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::TwistWithCovarianceStamped> TwistWithCovarianceStampedPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::TwistWithCovarianceStamped const> TwistWithCovarianceStampedConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator2> &rhs)
+  {
+    return lhs.header == rhs.header &&
+           lhs.twist == rhs.twist;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCESTAMPED_H

robot_geometry_msgs/include/robot_geometry_msgs/Vector3.h

@@ -0,0 +1,63 @@
+// Generated by gencpp from file robot_geometry_msgs/Vector3.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_VECTOR3_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_VECTOR3_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+namespace robot_geometry_msgs
+{
+  template <class ContainerAllocator>
+  struct Vector3_
+  {
+    typedef Vector3_<ContainerAllocator> Type;
+
+    Vector3_()
+        : x(0.0), y(0.0), z(0.0)
+    {
+    }
+    Vector3_(const ContainerAllocator &_alloc)
+        : x(0.0), y(0.0), z(0.0)
+    {
+      (void)_alloc;
+    }
+
+    typedef double _x_type;
+    _x_type x;
+
+    typedef double _y_type;
+    _y_type y;
+
+    typedef double _z_type;
+    _z_type z;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::Vector3_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::Vector3_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Vector3_
+
+  typedef ::robot_geometry_msgs::Vector3_<std::allocator<void>> Vector3;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::Vector3> Vector3Ptr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::Vector3 const> Vector3ConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::Vector3_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Vector3_<ContainerAllocator2> &rhs)
+  {
+    return lhs.x == rhs.x &&
+           lhs.y == rhs.y &&
+           lhs.z == rhs.z;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::Vector3_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Vector3_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_VECTOR3_H

robot_geometry_msgs/include/robot_geometry_msgs/Vector3Stamped.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_geometry_msgs/Vector3Stamped.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_VECTOR3STAMPED_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_VECTOR3STAMPED_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_std_msgs/Header.h>
+#include <robot_geometry_msgs/Vector3.h>
+
+namespace robot_geometry_msgs
+{
+  template <class ContainerAllocator>
+  struct Vector3Stamped_
+  {
+    typedef Vector3Stamped_<ContainerAllocator> Type;
+
+    Vector3Stamped_()
+        : header(), vector()
+    {
+    }
+    Vector3Stamped_(const ContainerAllocator &_alloc)
+        : header(_alloc), vector(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::robot_std_msgs::Header_<ContainerAllocator> _header_type;
+    _header_type header;
+
+    typedef ::robot_geometry_msgs::Vector3_<ContainerAllocator> _vector_type;
+    _vector_type vector;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::Vector3Stamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::Vector3Stamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Vector3Stamped_
+
+  typedef ::robot_geometry_msgs::Vector3Stamped_<std::allocator<void>> Vector3Stamped;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::Vector3Stamped> Vector3StampedPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::Vector3Stamped const> Vector3StampedConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::Vector3Stamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Vector3Stamped_<ContainerAllocator2> &rhs)
+  {
+    return lhs.header == rhs.header &&
+           lhs.vector == rhs.vector;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::Vector3Stamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Vector3Stamped_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_VECTOR3STAMPED_H

robot_geometry_msgs/include/robot_geometry_msgs/Wrench.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_geometry_msgs/Wrench.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_WRENCH_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_WRENCH_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_geometry_msgs/Vector3.h>
+#include <robot_geometry_msgs/Vector3.h>
+
+namespace robot_geometry_msgs
+{
+  template <class ContainerAllocator>
+  struct Wrench_
+  {
+    typedef Wrench_<ContainerAllocator> Type;
+
+    Wrench_()
+        : force(), torque()
+    {
+    }
+    Wrench_(const ContainerAllocator &_alloc)
+        : force(_alloc), torque(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::robot_geometry_msgs::Vector3_<ContainerAllocator> _force_type;
+    _force_type force;
+
+    typedef ::robot_geometry_msgs::Vector3_<ContainerAllocator> _torque_type;
+    _torque_type torque;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::Wrench_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::Wrench_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Wrench_
+
+  typedef ::robot_geometry_msgs::Wrench_<std::allocator<void>> Wrench;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::Wrench> WrenchPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::Wrench const> WrenchConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::Wrench_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Wrench_<ContainerAllocator2> &rhs)
+  {
+    return lhs.force == rhs.force &&
+           lhs.torque == rhs.torque;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::Wrench_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Wrench_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_WRENCH_H

robot_geometry_msgs/include/robot_geometry_msgs/WrenchStamped.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_geometry_msgs/WrenchStamped.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_GEOMETRY_MSGS_MESSAGE_WRENCHSTAMPED_H
+#define ROBOT_GEOMETRY_MSGS_MESSAGE_WRENCHSTAMPED_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_std_msgs/Header.h>
+#include <robot_geometry_msgs/Wrench.h>
+
+namespace robot_geometry_msgs
+{
+  template <class ContainerAllocator>
+  struct WrenchStamped_
+  {
+    typedef WrenchStamped_<ContainerAllocator> Type;
+
+    WrenchStamped_()
+        : header(), wrench()
+    {
+    }
+    WrenchStamped_(const ContainerAllocator &_alloc)
+        : header(_alloc), wrench(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::robot_std_msgs::Header_<ContainerAllocator> _header_type;
+    _header_type header;
+
+    typedef ::robot_geometry_msgs::Wrench_<ContainerAllocator> _wrench_type;
+    _wrench_type wrench;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::WrenchStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::WrenchStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct WrenchStamped_
+
+  typedef ::robot_geometry_msgs::WrenchStamped_<std::allocator<void>> WrenchStamped;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::WrenchStamped> WrenchStampedPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::WrenchStamped const> WrenchStampedConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::WrenchStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::WrenchStamped_<ContainerAllocator2> &rhs)
+  {
+    return lhs.header == rhs.header &&
+           lhs.wrench == rhs.wrench;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::WrenchStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::WrenchStamped_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // ROBOT_GEOMETRY_MSGS_MESSAGE_WRENCHSTAMPED_H

robot_geometry_msgs/package.xml

@@ -0,0 +1,28 @@
+<package>
+  <name>robot_geometry_msgs</name>
+  <version>0.7.10</version>
+  <description>
+    robot_geometry_msgs is the second generation of the transform library, which lets
+    the user keep track of multiple coordinate frames over time. robot_geometry_msgs
+    maintains the relationship between coordinate frames in a tree
+    structure buffered in time, and lets the user transform points,
+    vectors, etc between any two coordinate frames at any desired
+    point in time.
+  </description>
+  <author>Tully Foote</author>
+  <author>Eitan Marder-Eppstein</author>
+  <author>Wim Meeussen</author>
+  <maintainer email="tfoote@osrfoundation.org">Tully Foote</maintainer>
+  <license>BSD</license>
+
+  <url type="website">http://www.ros.org/wiki/robot_geometry_msgs</url>
+    
+  <buildtool_depend version_gte="0.5.68">catkin</buildtool_depend>
+
+  <build_depend>robot_std_msgs</build_depend>
+  <build_depend>robot_time</build_depend>
+
+  <run_depend>robot_std_msgs</run_depend>
+  <run_depend>robot_time</run_depend>
+
+</package>

robot_geometry_msgs/test/main.cpp

@@ -0,0 +1,39 @@
+#include "robot_geometry_msgs/PolygonStamped.h"
+#include <iostream>
+
+int main()
+{
+  robot_geometry_msgs::PolygonStamped poly_stamped;
+
+  poly_stamped.header.seq = 1;
+  poly_stamped.header.stamp.sec = 1625079042;
+  poly_stamped.header.stamp.nsec = 123456789;
+  poly_stamped.header.frame_id = "map";
+  poly_stamped.polygon.points.resize(3);
+  poly_stamped.polygon.points[0].x = 1.1;
+  poly_stamped.polygon.points[0].y = 2.5;
+  poly_stamped.polygon.points[0].z = 0.8;
+  poly_stamped.polygon.points[1].x = 2.1;
+  poly_stamped.polygon.points[1].y = 2.3;
+  poly_stamped.polygon.points[1].z = 0.3;
+  poly_stamped.polygon.points[2].x = 3.2;
+  poly_stamped.polygon.points[2].y = 5.9;
+  poly_stamped.polygon.points[2].z = 4.6;
+
+  std::cout << "PolygonStamped:" << std::endl;
+  std::cout << " Header:" << std::endl;
+  std::cout << "  seq: " << poly_stamped.header.seq << std::endl;
+  std::cout << "  stamp: " << poly_stamped.header.stamp.sec << "s " << poly_stamped.header.stamp.nsec << "ns" << std::endl;
+  std::cout << "  frame_id: " << poly_stamped.header.frame_id << std::endl;
+  std::cout << " Polygon points:" << std::endl;
+  for (size_t i = 0; i < poly_stamped.polygon.points.size(); ++i)
+  {
+    std::cout << "  Point " << i << ": ("
+              << poly_stamped.polygon.points[i].x << ", "
+              << poly_stamped.polygon.points[i].y << ", "
+              << poly_stamped.polygon.points[i].z << ")" << std::endl;
+  }
+
+
+  return 0;
+}

robot_map_msgs/CMakeLists.txt

@@ -0,0 +1,142 @@
+cmake_minimum_required(VERSION 3.0.2)
+project(robot_map_msgs VERSION 1.0.0 LANGUAGES CXX)
+
+if(DEFINED CATKIN_DEVEL_PREFIX OR DEFINED CATKIN_TOPLEVEL)
+  set(BUILDING_WITH_CATKIN TRUE)
+  message(STATUS "Building robot_map_msgs with Catkin")
+
+else()
+  set(BUILDING_WITH_CATKIN FALSE)
+  message(STATUS "Building robot_map_msgs with Standalone CMake")
+endif()
+
+# C++ Standard - must be set before find_package
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+if (NOT BUILDING_WITH_CATKIN)
+
+  # Enable Position Independent Code
+  set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+  # Cấu hình RPATH để tránh cycle trong runtime search path
+  set(CMAKE_BUILD_RPATH_USE_ORIGIN TRUE)
+  set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
+  set(CMAKE_BUILD_RPATH "${CMAKE_BINARY_DIR}")
+
+  set(PACKAGES_DIR  
+    robot_std_msgs
+  )
+
+else()
+
+# ========================================================
+# Catkin specific configuration
+# ========================================================
+  find_package(catkin REQUIRED COMPONENTS         
+    robot_std_msgs
+  )
+
+  catkin_package(
+    INCLUDE_DIRS include
+    # LIBRARIES không cần vì đây là header-only library
+    CATKIN_DEPENDS robot_std_msgs
+  )
+
+  include_directories(
+    include
+    ${catkin_INCLUDE_DIRS}
+  )
+endif()
+
+# Tìm tất cả header files
+file(GLOB_RECURSE HEADERS "include/robot_map_msgs/*.h")
+
+# Tạo INTERFACE library (header-only)
+add_library(${PROJECT_NAME} INTERFACE)
+
+if(BUILDING_WITH_CATKIN)
+  add_dependencies(${PROJECT_NAME} ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})
+
+  # Set include directories
+  target_include_directories(${PROJECT_NAME}
+    INTERFACE 
+      $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+      $<INSTALL_INTERFACE:include>
+  )
+
+  # Link dependencies (header-only, chỉ cần include paths)
+  target_link_libraries(${PROJECT_NAME}
+    INTERFACE
+      ${catkin_LIBRARIES}
+  )
+
+else()
+
+  # Set include directories
+  target_include_directories(${PROJECT_NAME}
+    INTERFACE 
+      $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+      $<INSTALL_INTERFACE:include>
+  )
+
+  # Link dependencies (header-only, chỉ cần include paths)
+  target_link_libraries(${PROJECT_NAME}
+    INTERFACE
+      ${PACKAGES_DIR}
+  )
+
+endif()
+
+if(BUILDING_WITH_CATKIN)
+  ## Mark libraries for installation
+  ## See http://docs.ros.org/melodic/api/catkin/html/howto/format1/building_libraries.html
+  install(TARGETS ${PROJECT_NAME}
+    ARCHIVE DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
+    LIBRARY DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
+    RUNTIME DESTINATION ${CATKIN_GLOBAL_BIN_DESTINATION}
+  )
+
+  ## Mark cpp header files for installation
+  install(DIRECTORY include/${PROJECT_NAME}/
+    DESTINATION ${CATKIN_PACKAGE_INCLUDE_DESTINATION}
+    FILES_MATCHING PATTERN "*.h"
+    PATTERN ".svn" EXCLUDE
+  )
+
+else()
+
+  install(TARGETS ${PROJECT_NAME}
+    EXPORT ${PROJECT_NAME}-targets
+    ARCHIVE DESTINATION lib
+    LIBRARY DESTINATION lib
+    RUNTIME DESTINATION bin
+  )
+
+  # Export targets
+  install(EXPORT ${PROJECT_NAME}-targets
+    FILE ${PROJECT_NAME}-targets.cmake
+    NAMESPACE ${PROJECT_NAME}::
+    DESTINATION lib/cmake/${PROJECT_NAME}
+  )
+
+  ## Mark cpp header files for installation
+  install(DIRECTORY include/${PROJECT_NAME}/
+    DESTINATION include
+    FILES_MATCHING PATTERN "*.h"
+    PATTERN ".svn" EXCLUDE
+  )
+
+  # Print configuration info
+  message(STATUS "=================================")
+  message(STATUS "Project: ${PROJECT_NAME} (Header-Only)")
+  message(STATUS "Version: ${PROJECT_VERSION}")
+  message(STATUS "C++ Standard: ${CMAKE_CXX_STANDARD}")
+  message(STATUS "Headers found:")
+  foreach(hdr ${HEADERS})
+    message(STATUS "  - ${hdr}")
+  endforeach()
+  message(STATUS "Dependencies: robot_std_msgs")
+  message(STATUS "=================================")
+endif()

robot_map_msgs/include/robot_map_msgs/OccupancyGridUpdate.h

@@ -0,0 +1,36 @@
+#ifndef ROBOT_OCCUPANCY_GRID_UPDATE_H
+#define ROBOT_OCCUPANCY_GRID_UPDATE_H
+
+#include <vector>
+#include <robot_std_msgs/Header.h>
+
+namespace robot_map_msgs
+{
+struct OccupancyGridUpdate
+{
+    robot_std_msgs::Header header;  // Thời gian và frame của bản đồ cập nhật
+    int32_t x;                // Tọa độ x của góc trên bên trái của vùng cập nhật trong bản đồ
+    int32_t y;                // Tọa độ y của góc trên bên trái của vùng cập nhật trong bản đồ
+    uint32_t width;           // Chiều rộng của vùng cập nhật
+    uint32_t height;          // Chiều cao của vùng cập nhật
+    std::vector<int8_t> data; // Dữ liệu cập nhật của vùng (giá trị từ -1 đến 100, trong đó -1 là không biết, 0 là không có chướng ngại vật, và 100 là chướng ngại vật chắc chắn
+    OccupancyGridUpdate() = default;
+};
+
+inline bool operator==(const robot_map_msgs::OccupancyGridUpdate & lhs, const robot_map_msgs::OccupancyGridUpdate & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.x == rhs.x &&
+    lhs.y == rhs.y &&
+    lhs.width == rhs.width &&
+    lhs.height == rhs.height &&
+    lhs.data == rhs.data;
+}
+
+
+inline bool operator!=(const robot_map_msgs::OccupancyGridUpdate & lhs, const robot_map_msgs::OccupancyGridUpdate & rhs)
+{
+  return !(lhs == rhs);
+}
+} // namespace robot_map_msgs
+#endif

robot_map_msgs/package.xml

@@ -0,0 +1,20 @@
+<package>
+  <name>robot_map_msgs</name>
+  <version>0.7.10</version>
+  <description>
+    robot_map_msgs provides message types for map-related data structures.
+  </description>
+  <author>Tully Foote</author>
+  <author>Eitan Marder-Eppstein</author>
+  <author>Wim Meeussen</author>
+  <maintainer email="tfoote@osrfoundation.org">Tully Foote</maintainer>
+  <license>BSD</license>
+
+  <url type="website">http://www.ros.org/wiki/robot_map_msgs</url>
+    
+  <buildtool_depend version_gte="0.5.68">catkin</buildtool_depend>
+
+  <build_depend>robot_std_msgs</build_depend>
+  <run_depend>robot_std_msgs</run_depend>
+
+</package>

robot_nav_msgs/CMakeLists.txt

@@ -0,0 +1,152 @@
+cmake_minimum_required(VERSION 3.0.2)
+project(robot_nav_msgs VERSION 1.0.0 LANGUAGES CXX)
+
+if(DEFINED CATKIN_DEVEL_PREFIX OR DEFINED CATKIN_TOPLEVEL)
+  set(BUILDING_WITH_CATKIN TRUE)
+  message(STATUS "Building robot_nav_msgs with Catkin")
+
+else()
+  set(BUILDING_WITH_CATKIN FALSE)
+  message(STATUS "Building robot_nav_msgs with Standalone CMake")
+endif()
+
+# C++ Standard - must be set before find_package
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+if (NOT BUILDING_WITH_CATKIN)
+
+  # Enable Position Independent Code
+  set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+  # Cấu hình RPATH để tránh cycle trong runtime search path
+  set(CMAKE_BUILD_RPATH_USE_ORIGIN TRUE)
+  set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
+  set(CMAKE_BUILD_RPATH "${CMAKE_BINARY_DIR}")
+
+  set(PACKAGES_DIR  
+    robot_std_msgs
+    robot_geometry_msgs
+  )
+
+else()
+
+# ========================================================
+# Catkin specific configuration
+# ========================================================
+  find_package(catkin REQUIRED COMPONENTS         
+    robot_std_msgs
+    robot_geometry_msgs
+  )
+
+  catkin_package(
+    INCLUDE_DIRS include
+    # LIBRARIES không cần vì đây là header-only library
+    CATKIN_DEPENDS robot_std_msgs robot_geometry_msgs
+  )
+
+  include_directories(
+    include
+    ${catkin_INCLUDE_DIRS}
+  )
+endif()
+
+# Tìm tất cả header files
+file(GLOB_RECURSE HEADERS "include/robot_nav_msgs/*.h")
+
+# Tạo INTERFACE library (header-only)
+add_library(${PROJECT_NAME} INTERFACE)
+
+if(BUILDING_WITH_CATKIN)
+  add_dependencies(${PROJECT_NAME} ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})
+
+  # Set include directories
+  target_include_directories(${PROJECT_NAME}
+    INTERFACE 
+      $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+      $<INSTALL_INTERFACE:include>
+  )
+
+  # Link dependencies (header-only, chỉ cần include paths)
+  target_link_libraries(${PROJECT_NAME}
+    INTERFACE
+      ${catkin_LIBRARIES}
+  )
+
+else()
+
+  # Set include directories
+  target_include_directories(${PROJECT_NAME}
+    INTERFACE 
+      $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+      $<INSTALL_INTERFACE:include>
+  )
+
+  # Link dependencies (header-only, chỉ cần include paths)
+  target_link_libraries(${PROJECT_NAME}
+    INTERFACE
+      ${PACKAGES_DIR}
+  )
+
+endif()
+
+if(BUILDING_WITH_CATKIN)
+  ## Mark libraries for installation
+  ## See http://docs.ros.org/melodic/api/catkin/html/howto/format1/building_libraries.html
+  install(TARGETS ${PROJECT_NAME}
+    ARCHIVE DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
+    LIBRARY DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
+    RUNTIME DESTINATION ${CATKIN_GLOBAL_BIN_DESTINATION}
+  )
+
+  ## Mark cpp header files for installation
+  install(DIRECTORY include/${PROJECT_NAME}/
+    DESTINATION ${CATKIN_PACKAGE_INCLUDE_DESTINATION}
+    FILES_MATCHING PATTERN "*.h"
+    PATTERN ".svn" EXCLUDE
+  )
+
+else()
+
+  install(TARGETS ${PROJECT_NAME}
+    EXPORT ${PROJECT_NAME}-targets
+    ARCHIVE DESTINATION lib
+    LIBRARY DESTINATION lib
+    RUNTIME DESTINATION bin
+  )
+
+  # Export targets
+  install(EXPORT ${PROJECT_NAME}-targets
+    FILE ${PROJECT_NAME}-targets.cmake
+    NAMESPACE ${PROJECT_NAME}::
+    DESTINATION lib/cmake/${PROJECT_NAME}
+  )
+
+  ## Mark cpp header files for installation
+  install(DIRECTORY include/${PROJECT_NAME}/
+    DESTINATION include
+    FILES_MATCHING PATTERN "*.h"
+    PATTERN ".svn" EXCLUDE
+  )
+
+  # Print configuration info
+  message(STATUS "=================================")
+  message(STATUS "Project: ${PROJECT_NAME} (Header-Only)")
+  message(STATUS "Version: ${PROJECT_VERSION}")
+  message(STATUS "C++ Standard: ${CMAKE_CXX_STANDARD}")
+  message(STATUS "Headers found:")
+  foreach(hdr ${HEADERS})
+    message(STATUS "  - ${hdr}")
+  endforeach()
+  message(STATUS "Dependencies: robot_std_msgs, robot_geometry_msgs")
+  message(STATUS "=================================")
+endif()
+
+# ========================================================
+# Test executables
+# ========================================================
+if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/test/main.cpp)
+  add_executable(${PROJECT_NAME}_test test/main.cpp)
+  target_link_libraries(${PROJECT_NAME}_test PRIVATE ${PROJECT_NAME})
+endif()

robot_nav_msgs/include/robot_nav_msgs/GetMap.h

@@ -0,0 +1,27 @@
+// Generated by gencpp from file robot_nav_msgs/GetMap.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_NAV_MSGS_MESSAGE_GETMAP_H
+#define ROBOT_NAV_MSGS_MESSAGE_GETMAP_H
+
+#include <robot_nav_msgs/GetMapRequest.h>
+#include <robot_nav_msgs/GetMapResponse.h>
+
+namespace robot_nav_msgs
+{
+
+  struct GetMap
+  {
+
+    typedef GetMapRequest Request;
+    typedef GetMapResponse Response;
+    Request request;
+    Response response;
+
+    typedef Request RequestType;
+    typedef Response ResponseType;
+
+  }; // struct GetMap
+} // namespace robot_nav_msgs
+
+#endif // ROBOT_NAV_MSGS_MESSAGE_GETMAP_H

robot_nav_msgs/include/robot_nav_msgs/GetMapAction.h

@@ -0,0 +1,70 @@
+// Generated by gencpp from file robot_nav_msgs/GetMapAction.msg
+// DO NOT EDIT!
+
+#ifndef ROBOT_NAV_MSGS_MESSAGE_GETMAPACTION_H
+#define ROBOT_NAV_MSGS_MESSAGE_GETMAPACTION_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_nav_msgs/GetMapActionGoal.h>
+#include <robot_nav_msgs/GetMapActionResult.h>
+#include <robot_nav_msgs/GetMapActionFeedback.h>
+
+namespace robot_nav_msgs
+{
+  template <class ContainerAllocator>
+  struct GetMapAction_
+  {
+    typedef GetMapAction_<ContainerAllocator> Type;
+
+    GetMapAction_()
+        : action_goal(), action_result(), action_feedback()
+    {
+    }
+    GetMapAction_(const ContainerAllocator &_alloc)
+        : action_goal(_alloc), action_result(_alloc), action_feedback(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::robot_nav_msgs::GetMapActionGoal_<ContainerAllocator> _action_goal_type;
+    _action_goal_type action_goal;
+
+    typedef ::robot_nav_msgs::GetMapActionResult_<ContainerAllocator> _action_result_type;
+    _action_result_type action_result;
+
+    typedef ::robot_nav_msgs::GetMapActionFeedback_<ContainerAllocator> _action_feedback_type;
+    _action_feedback_type action_feedback;
+
+    typedef boost::shared_ptr<::robot_nav_msgs::GetMapAction_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_nav_msgs::GetMapAction_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct GetMapAction_
+
+  typedef ::robot_nav_msgs::GetMapAction_<std::allocator<void>> GetMapAction;
+
+  typedef boost::shared_ptr<::robot_nav_msgs::GetMapAction> GetMapActionPtr;
+  typedef boost::shared_ptr<::robot_nav_msgs::GetMapAction const> GetMapActionConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_nav_msgs::GetMapAction_<ContainerAllocator1> &lhs, const ::robot_nav_msgs::GetMapAction_<ContainerAllocator2> &rhs)
+  {
+    return lhs.action_goal == rhs.action_goal &&
+           lhs.action_result == rhs.action_result &&
+           lhs.action_feedback == rhs.action_feedback;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_nav_msgs::GetMapAction_<ContainerAllocator1> &lhs, const ::robot_nav_msgs::GetMapAction_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_nav_msgs
+
+#endif // ROBOT_NAV_MSGS_MESSAGE_GETMAPACTION_H

robot_nav_msgs/include/robot_nav_msgs/GetMapActionFeedback.h

@@ -0,0 +1,77 @@
+// Generated by gencpp from file robot_nav_msgs/GetMapActionFeedback.msg
+// DO NOT EDIT!
+
+
+#ifndef ROBOT_NAV_MSGS_MESSAGE_GETMAPACTIONFEEDBACK_H
+#define ROBOT_NAV_MSGS_MESSAGE_GETMAPACTIONFEEDBACK_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_std_msgs/Header.h>
+#include <actionlib_msgs/GoalStatus.h>
+#include <robot_nav_msgs/GetMapFeedback.h>
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapActionFeedback_
+{
+  typedef GetMapActionFeedback_<ContainerAllocator> Type;
+
+  GetMapActionFeedback_()
+    : header()
+    , status()
+    , feedback()  {
+    }
+  GetMapActionFeedback_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , status(_alloc)
+    , feedback(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::robot_std_msgs::Header  _header_type;
+  _header_type header;
+
+   typedef  ::actionlib_msgs::GoalStatus_<ContainerAllocator>  _status_type;
+  _status_type status;
+
+   typedef  ::robot_nav_msgs::GetMapFeedback_<ContainerAllocator>  _feedback_type;
+  _feedback_type feedback;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapActionFeedback_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapActionFeedback_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapActionFeedback_
+
+typedef ::robot_nav_msgs::GetMapActionFeedback_<std::allocator<void> > GetMapActionFeedback;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapActionFeedback > GetMapActionFeedbackPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapActionFeedback const> GetMapActionFeedbackConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::GetMapActionFeedback_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GetMapActionFeedback_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.status == rhs.status &&
+    lhs.feedback == rhs.feedback;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::GetMapActionFeedback_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GetMapActionFeedback_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // ROBOT_NAV_MSGS_MESSAGE_GETMAPACTIONFEEDBACK_H

robot_nav_msgs/include/robot_nav_msgs/GetMapActionGoal.h

@@ -0,0 +1,77 @@
+// Generated by gencpp from file robot_nav_msgs/GetMapActionGoal.msg
+// DO NOT EDIT!
+
+
+#ifndef ROBOT_NAV_MSGS_MESSAGE_GETMAPACTIONGOAL_H
+#define ROBOT_NAV_MSGS_MESSAGE_GETMAPACTIONGOAL_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_std_msgs/Header.h>
+#include <actionlib_msgs/GoalID.h>
+#include <robot_nav_msgs/GetMapGoal.h>
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapActionGoal_
+{
+  typedef GetMapActionGoal_<ContainerAllocator> Type;
+
+  GetMapActionGoal_()
+    : header()
+    , goal_id()
+    , goal()  {
+    }
+  GetMapActionGoal_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , goal_id(_alloc)
+    , goal(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::robot_std_msgs::Header  _header_type;
+  _header_type header;
+
+   typedef  ::actionlib_msgs::GoalID_<ContainerAllocator>  _goal_id_type;
+  _goal_id_type goal_id;
+
+   typedef  ::robot_nav_msgs::GetMapGoal_<ContainerAllocator>  _goal_type;
+  _goal_type goal;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapActionGoal_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapActionGoal_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapActionGoal_
+
+typedef ::robot_nav_msgs::GetMapActionGoal_<std::allocator<void> > GetMapActionGoal;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapActionGoal > GetMapActionGoalPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapActionGoal const> GetMapActionGoalConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::GetMapActionGoal_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GetMapActionGoal_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.goal_id == rhs.goal_id &&
+    lhs.goal == rhs.goal;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::GetMapActionGoal_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GetMapActionGoal_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // ROBOT_NAV_MSGS_MESSAGE_GETMAPACTIONGOAL_H

robot_nav_msgs/include/robot_nav_msgs/GetMapActionResult.h

@@ -0,0 +1,77 @@
+// Generated by gencpp from file robot_nav_msgs/GetMapActionResult.msg
+// DO NOT EDIT!
+
+
+#ifndef ROBOT_NAV_MSGS_MESSAGE_GETMAPACTIONRESULT_H
+#define ROBOT_NAV_MSGS_MESSAGE_GETMAPACTIONRESULT_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_std_msgs/Header.h>
+#include <actionlib_msgs/GoalStatus.h>
+#include <robot_nav_msgs/GetMapResult.h>
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapActionResult_
+{
+  typedef GetMapActionResult_<ContainerAllocator> Type;
+
+  GetMapActionResult_()
+    : header()
+    , status()
+    , result()  {
+    }
+  GetMapActionResult_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , status(_alloc)
+    , result(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::robot_std_msgs::Header  _header_type;
+  _header_type header;
+
+   typedef  ::actionlib_msgs::GoalStatus_<ContainerAllocator>  _status_type;
+  _status_type status;
+
+   typedef  ::robot_nav_msgs::GetMapResult_<ContainerAllocator>  _result_type;
+  _result_type result;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapActionResult_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapActionResult_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapActionResult_
+
+typedef ::robot_nav_msgs::GetMapActionResult_<std::allocator<void> > GetMapActionResult;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapActionResult > GetMapActionResultPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapActionResult const> GetMapActionResultConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::GetMapActionResult_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GetMapActionResult_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.status == rhs.status &&
+    lhs.result == rhs.result;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::GetMapActionResult_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GetMapActionResult_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // ROBOT_NAV_MSGS_MESSAGE_GETMAPACTIONRESULT_H

robot_nav_msgs/include/robot_nav_msgs/GetMapFeedback.h

@@ -0,0 +1,45 @@
+// Generated by gencpp from file robot_nav_msgs/GetMapFeedback.msg
+// DO NOT EDIT!
+
+
+#ifndef ROBOT_NAV_MSGS_MESSAGE_GETMAPFEEDBACK_H
+#define ROBOT_NAV_MSGS_MESSAGE_GETMAPFEEDBACK_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapFeedback_
+{
+  typedef GetMapFeedback_<ContainerAllocator> Type;
+
+  GetMapFeedback_()
+    {
+    }
+  GetMapFeedback_(const ContainerAllocator& _alloc)
+    {
+  (void)_alloc;
+    }
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapFeedback_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapFeedback_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapFeedback_
+
+typedef ::robot_nav_msgs::GetMapFeedback_<std::allocator<void> > GetMapFeedback;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapFeedback > GetMapFeedbackPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapFeedback const> GetMapFeedbackConstPtr;
+
+} // namespace robot_nav_msgs
+
+#endif // ROBOT_NAV_MSGS_MESSAGE_GETMAPFEEDBACK_H

robot_nav_msgs/include/robot_nav_msgs/GetMapGoal.h

@@ -0,0 +1,45 @@
+// Generated by gencpp from file robot_nav_msgs/GetMapGoal.msg
+// DO NOT EDIT!
+
+
+#ifndef ROBOT_NAV_MSGS_MESSAGE_GETMAPGOAL_H
+#define ROBOT_NAV_MSGS_MESSAGE_GETMAPGOAL_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapGoal_
+{
+  typedef GetMapGoal_<ContainerAllocator> Type;
+
+  GetMapGoal_()
+    {
+    }
+  GetMapGoal_(const ContainerAllocator& _alloc)
+    {
+  (void)_alloc;
+    }
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapGoal_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapGoal_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapGoal_
+
+typedef ::robot_nav_msgs::GetMapGoal_<std::allocator<void> > GetMapGoal;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapGoal > GetMapGoalPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapGoal const> GetMapGoalConstPtr;
+
+} // namespace robot_nav_msgs
+
+#endif // ROBOT_NAV_MSGS_MESSAGE_GETMAPGOAL_H

robot_nav_msgs/include/robot_nav_msgs/GetMapRequest.h

@@ -0,0 +1,45 @@
+// Generated by gencpp from file robot_nav_msgs/GetMapRequest.msg
+// DO NOT EDIT!
+
+
+#ifndef ROBOT_NAV_MSGS_MESSAGE_GETMAPREQUEST_H
+#define ROBOT_NAV_MSGS_MESSAGE_GETMAPREQUEST_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapRequest_
+{
+  typedef GetMapRequest_<ContainerAllocator> Type;
+
+  GetMapRequest_()
+    {
+    }
+  GetMapRequest_(const ContainerAllocator& _alloc)
+    {
+  (void)_alloc;
+    }
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapRequest_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapRequest_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapRequest_
+
+typedef ::robot_nav_msgs::GetMapRequest_<std::allocator<void> > GetMapRequest;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapRequest > GetMapRequestPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapRequest const> GetMapRequestConstPtr;
+
+} // namespace robot_nav_msgs
+
+#endif // ROBOT_NAV_MSGS_MESSAGE_GETMAPREQUEST_H

robot_nav_msgs/include/robot_nav_msgs/GetMapResponse.h

@@ -0,0 +1,63 @@
+// Generated by gencpp from file robot_nav_msgs/GetMapResponse.msg
+// DO NOT EDIT!
+
+
+#ifndef ROBOT_NAV_MSGS_MESSAGE_GETMAPRESPONSE_H
+#define ROBOT_NAV_MSGS_MESSAGE_GETMAPRESPONSE_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_nav_msgs/OccupancyGrid.h>
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapResponse_
+{
+  typedef GetMapResponse_<ContainerAllocator> Type;
+
+  GetMapResponse_()
+    : map()  {
+    }
+  GetMapResponse_(const ContainerAllocator& _alloc)
+    : map(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::robot_nav_msgs::OccupancyGrid_<ContainerAllocator>  _map_type;
+  _map_type map;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapResponse_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapResponse_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapResponse_
+
+typedef ::robot_nav_msgs::GetMapResponse_<std::allocator<void> > GetMapResponse;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapResponse > GetMapResponsePtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapResponse const> GetMapResponseConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::GetMapResponse_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GetMapResponse_<ContainerAllocator2> & rhs)
+{
+  return lhs.map == rhs.map;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::GetMapResponse_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GetMapResponse_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // ROBOT_NAV_MSGS_MESSAGE_GETMAPRESPONSE_H

robot_nav_msgs/include/robot_nav_msgs/GetMapResult.h

@@ -0,0 +1,63 @@
+// Generated by gencpp from file robot_nav_msgs/GetMapResult.msg
+// DO NOT EDIT!
+
+
+#ifndef ROBOT_NAV_MSGS_MESSAGE_GETMAPRESULT_H
+#define ROBOT_NAV_MSGS_MESSAGE_GETMAPRESULT_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_nav_msgs/OccupancyGrid.h>
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapResult_
+{
+  typedef GetMapResult_<ContainerAllocator> Type;
+
+  GetMapResult_()
+    : map()  {
+    }
+  GetMapResult_(const ContainerAllocator& _alloc)
+    : map(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::robot_nav_msgs::OccupancyGrid_<ContainerAllocator>  _map_type;
+  _map_type map;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapResult_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapResult_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapResult_
+
+typedef ::robot_nav_msgs::GetMapResult_<std::allocator<void> > GetMapResult;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapResult > GetMapResultPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapResult const> GetMapResultConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::GetMapResult_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GetMapResult_<ContainerAllocator2> & rhs)
+{
+  return lhs.map == rhs.map;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::GetMapResult_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GetMapResult_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // ROBOT_NAV_MSGS_MESSAGE_GETMAPRESULT_H

robot_nav_msgs/include/robot_nav_msgs/GetPlan.h

@@ -0,0 +1,30 @@
+// Generated by gencpp from file robot_nav_msgs/GetPlan.msg
+// DO NOT EDIT!
+
+
+#ifndef ROBOT_NAV_MSGS_MESSAGE_GETPLAN_H
+#define ROBOT_NAV_MSGS_MESSAGE_GETPLAN_H
+
+
+#include <robot_nav_msgs/GetPlanRequest.h>
+#include <robot_nav_msgs/GetPlanResponse.h>
+
+
+namespace robot_nav_msgs
+{
+
+struct GetPlan
+{
+
+typedef GetPlanRequest Request;
+typedef GetPlanResponse Response;
+Request request;
+Response response;
+
+typedef Request RequestType;
+typedef Response ResponseType;
+
+}; // struct GetPlan
+} // namespace robot_nav_msgs
+
+#endif // ROBOT_NAV_MSGS_MESSAGE_GETPLAN_H

robot_nav_msgs/include/robot_nav_msgs/GetPlanRequest.h

@@ -0,0 +1,75 @@
+// Generated by gencpp from file robot_nav_msgs/GetPlanRequest.msg
+// DO NOT EDIT!
+
+
+#ifndef ROBOT_NAV_MSGS_MESSAGE_GETPLANREQUEST_H
+#define ROBOT_NAV_MSGS_MESSAGE_GETPLANREQUEST_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_geometry_msgs/PoseStamped.h>
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct GetPlanRequest_
+{
+  typedef GetPlanRequest_<ContainerAllocator> Type;
+
+  GetPlanRequest_()
+    : start()
+    , goal()
+    , tolerance(0.0)  {
+    }
+  GetPlanRequest_(const ContainerAllocator& _alloc)
+    : start(_alloc)
+    , goal(_alloc)
+    , tolerance(0.0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::robot_geometry_msgs::PoseStamped  _start_type;
+  _start_type start;
+
+   typedef  ::robot_geometry_msgs::PoseStamped  _goal_type;
+  _goal_type goal;
+
+   typedef float _tolerance_type;
+  _tolerance_type tolerance;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetPlanRequest_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetPlanRequest_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetPlanRequest_
+
+typedef ::robot_nav_msgs::GetPlanRequest_<std::allocator<void> > GetPlanRequest;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::GetPlanRequest > GetPlanRequestPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::GetPlanRequest const> GetPlanRequestConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::GetPlanRequest_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GetPlanRequest_<ContainerAllocator2> & rhs)
+{
+  return lhs.start == rhs.start &&
+    lhs.goal == rhs.goal &&
+    lhs.tolerance == rhs.tolerance;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::GetPlanRequest_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GetPlanRequest_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // ROBOT_NAV_MSGS_MESSAGE_GETPLANREQUEST_H

robot_nav_msgs/include/robot_nav_msgs/GetPlanResponse.h

@@ -0,0 +1,63 @@
+// Generated by gencpp from file robot_nav_msgs/GetPlanResponse.msg
+// DO NOT EDIT!
+
+
+#ifndef ROBOT_NAV_MSGS_MESSAGE_GETPLANRESPONSE_H
+#define ROBOT_NAV_MSGS_MESSAGE_GETPLANRESPONSE_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_nav_msgs/Path.h>
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct GetPlanResponse_
+{
+  typedef GetPlanResponse_<ContainerAllocator> Type;
+
+  GetPlanResponse_()
+    : plan()  {
+    }
+  GetPlanResponse_(const ContainerAllocator& _alloc)
+    : plan(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::robot_nav_msgs::Path_<ContainerAllocator>  _plan_type;
+  _plan_type plan;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetPlanResponse_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetPlanResponse_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetPlanResponse_
+
+typedef ::robot_nav_msgs::GetPlanResponse_<std::allocator<void> > GetPlanResponse;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::GetPlanResponse > GetPlanResponsePtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::GetPlanResponse const> GetPlanResponseConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::GetPlanResponse_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GetPlanResponse_<ContainerAllocator2> & rhs)
+{
+  return lhs.plan == rhs.plan;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::GetPlanResponse_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GetPlanResponse_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // ROBOT_NAV_MSGS_MESSAGE_GETPLANRESPONSE_H

robot_nav_msgs/include/robot_nav_msgs/GridCells.h

@@ -0,0 +1,82 @@
+// Generated by gencpp from file robot_nav_msgs/GridCells.msg
+// DO NOT EDIT!
+
+
+#ifndef ROBOT_NAV_MSGS_MESSAGE_GRIDCELLS_H
+#define ROBOT_NAV_MSGS_MESSAGE_GRIDCELLS_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_std_msgs/Header.h>
+#include <robot_geometry_msgs/Point.h>
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct GridCells_
+{
+  typedef GridCells_<ContainerAllocator> Type;
+
+  GridCells_()
+    : header()
+    , cell_width(0.0)
+    , cell_height(0.0)
+    , cells()  {
+    }
+  GridCells_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , cell_width(0.0)
+    , cell_height(0.0)
+    , cells(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::robot_std_msgs::Header  _header_type;
+  _header_type header;
+
+   typedef float _cell_width_type;
+  _cell_width_type cell_width;
+
+   typedef float _cell_height_type;
+  _cell_height_type cell_height;
+
+   typedef std::vector< ::robot_geometry_msgs::Point , typename std::allocator_traits<ContainerAllocator>::template rebind_alloc< ::robot_geometry_msgs::Point >> _cells_type;
+  _cells_type cells;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::GridCells_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::GridCells_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GridCells_
+
+typedef ::robot_nav_msgs::GridCells_<std::allocator<void> > GridCells;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::GridCells > GridCellsPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::GridCells const> GridCellsConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::GridCells_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GridCells_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.cell_width == rhs.cell_width &&
+    lhs.cell_height == rhs.cell_height &&
+    lhs.cells == rhs.cells;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::GridCells_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GridCells_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // ROBOT_NAV_MSGS_MESSAGE_GRIDCELLS_H

robot_nav_msgs/include/robot_nav_msgs/LoadMap.h

@@ -0,0 +1,30 @@
+// Generated by gencpp from file robot_nav_msgs/LoadMap.msg
+// DO NOT EDIT!
+
+
+#ifndef ROBOT_NAV_MSGS_MESSAGE_LOADMAP_H
+#define ROBOT_NAV_MSGS_MESSAGE_LOADMAP_H
+
+
+#include <robot_nav_msgs/LoadMapRequest.h>
+#include <robot_nav_msgs/LoadMapResponse.h>
+
+
+namespace robot_nav_msgs
+{
+
+struct LoadMap
+{
+
+typedef LoadMapRequest Request;
+typedef LoadMapResponse Response;
+Request request;
+Response response;
+
+typedef Request RequestType;
+typedef Response ResponseType;
+
+}; // struct LoadMap
+} // namespace robot_nav_msgs
+
+#endif // ROBOT_NAV_MSGS_MESSAGE_LOADMAP_H

robot_nav_msgs/include/robot_nav_msgs/LoadMapRequest.h

@@ -0,0 +1,62 @@
+// Generated by gencpp from file robot_nav_msgs/LoadMapRequest.msg
+// DO NOT EDIT!
+
+
+#ifndef ROBOT_NAV_MSGS_MESSAGE_LOADMAPREQUEST_H
+#define ROBOT_NAV_MSGS_MESSAGE_LOADMAPREQUEST_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct LoadMapRequest_
+{
+  typedef LoadMapRequest_<ContainerAllocator> Type;
+
+  LoadMapRequest_()
+    : map_url()  {
+    }
+  LoadMapRequest_(const ContainerAllocator& _alloc)
+    : map_url(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _map_url_type;
+  _map_url_type map_url;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::LoadMapRequest_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::LoadMapRequest_<ContainerAllocator> const> ConstPtr;
+
+}; // struct LoadMapRequest_
+
+typedef ::robot_nav_msgs::LoadMapRequest_<std::allocator<void> > LoadMapRequest;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::LoadMapRequest > LoadMapRequestPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::LoadMapRequest const> LoadMapRequestConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::LoadMapRequest_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::LoadMapRequest_<ContainerAllocator2> & rhs)
+{
+  return lhs.map_url == rhs.map_url;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::LoadMapRequest_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::LoadMapRequest_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // ROBOT_NAV_MSGS_MESSAGE_LOADMAPREQUEST_H

robot_nav_msgs/include/robot_nav_msgs/LoadMapResponse.h

@@ -0,0 +1,94 @@
+// Generated by gencpp from file robot_nav_msgs/LoadMapResponse.msg
+// DO NOT EDIT!
+
+
+#ifndef ROBOT_NAV_MSGS_MESSAGE_LOADMAPRESPONSE_H
+#define ROBOT_NAV_MSGS_MESSAGE_LOADMAPRESPONSE_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_nav_msgs/OccupancyGrid.h>
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct LoadMapResponse_
+{
+  typedef LoadMapResponse_<ContainerAllocator> Type;
+
+  LoadMapResponse_()
+    : map()
+    , result(0)  {
+    }
+  LoadMapResponse_(const ContainerAllocator& _alloc)
+    : map(_alloc)
+    , result(0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::robot_nav_msgs::OccupancyGrid_<ContainerAllocator>  _map_type;
+  _map_type map;
+
+   typedef uint8_t _result_type;
+  _result_type result;
+
+
+
+// reducing the odds to have name collisions with Windows.h 
+#if defined(_WIN32) && defined(RESULT_SUCCESS)
+  #undef RESULT_SUCCESS
+#endif
+#if defined(_WIN32) && defined(RESULT_MAP_DOES_NOT_EXIST)
+  #undef RESULT_MAP_DOES_NOT_EXIST
+#endif
+#if defined(_WIN32) && defined(RESULT_INVALID_MAP_DATA)
+  #undef RESULT_INVALID_MAP_DATA
+#endif
+#if defined(_WIN32) && defined(RESULT_INVALID_MAP_METADATA)
+  #undef RESULT_INVALID_MAP_METADATA
+#endif
+#if defined(_WIN32) && defined(RESULT_UNDEFINED_FAILURE)
+  #undef RESULT_UNDEFINED_FAILURE
+#endif
+
+  enum {
+    RESULT_SUCCESS = 0u,
+    RESULT_MAP_DOES_NOT_EXIST = 1u,
+    RESULT_INVALID_MAP_DATA = 2u,
+    RESULT_INVALID_MAP_METADATA = 3u,
+    RESULT_UNDEFINED_FAILURE = 255u,
+  };
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::LoadMapResponse_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::LoadMapResponse_<ContainerAllocator> const> ConstPtr;
+
+}; // struct LoadMapResponse_
+
+typedef ::robot_nav_msgs::LoadMapResponse_<std::allocator<void> > LoadMapResponse;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::LoadMapResponse > LoadMapResponsePtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::LoadMapResponse const> LoadMapResponseConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::LoadMapResponse_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::LoadMapResponse_<ContainerAllocator2> & rhs)
+{
+  return lhs.map == rhs.map &&
+    lhs.result == rhs.result;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::LoadMapResponse_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::LoadMapResponse_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // ROBOT_NAV_MSGS_MESSAGE_LOADMAPRESPONSE_H

robot_nav_msgs/include/robot_nav_msgs/MapMetaData.h

@@ -0,0 +1,88 @@
+// Generated by gencpp from file robot_nav_msgs/MapMetaData.msg
+// DO NOT EDIT!
+
+
+#ifndef ROBOT_NAV_MSGS_MESSAGE_MAPMETADATA_H
+#define ROBOT_NAV_MSGS_MESSAGE_MAPMETADATA_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot/time.h>
+#include <robot_geometry_msgs/Pose.h>
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct MapMetaData_
+{
+  typedef MapMetaData_<ContainerAllocator> Type;
+
+  MapMetaData_()
+    : map_load_time()
+    , resolution(0.0)
+    , width(0)
+    , height(0)
+    , origin()  {
+    }
+  MapMetaData_(const ContainerAllocator& _alloc)
+    : map_load_time()
+    , resolution(0.0)
+    , width(0)
+    , height(0)
+    , origin(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef robot::Time _map_load_time_type;
+  _map_load_time_type map_load_time;
+
+   typedef float _resolution_type;
+  _resolution_type resolution;
+
+   typedef uint32_t _width_type;
+  _width_type width;
+
+   typedef uint32_t _height_type;
+  _height_type height;
+
+   typedef  ::robot_geometry_msgs::Pose  _origin_type;
+  _origin_type origin;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::MapMetaData_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::MapMetaData_<ContainerAllocator> const> ConstPtr;
+
+}; // struct MapMetaData_
+
+typedef ::robot_nav_msgs::MapMetaData_<std::allocator<void> > MapMetaData;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::MapMetaData > MapMetaDataPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::MapMetaData const> MapMetaDataConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::MapMetaData_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::MapMetaData_<ContainerAllocator2> & rhs)
+{
+  return lhs.map_load_time == rhs.map_load_time &&
+    lhs.resolution == rhs.resolution &&
+    lhs.width == rhs.width &&
+    lhs.height == rhs.height &&
+    lhs.origin == rhs.origin;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::MapMetaData_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::MapMetaData_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // ROBOT_NAV_MSGS_MESSAGE_MAPMETADATA_H

robot_nav_msgs/include/robot_nav_msgs/OccupancyGrid.h

@@ -0,0 +1,76 @@
+// Generated by gencpp from file robot_nav_msgs/OccupancyGrid.msg
+// DO NOT EDIT!
+
+
+#ifndef ROBOT_NAV_MSGS_MESSAGE_OCCUPANCYGRID_H
+#define ROBOT_NAV_MSGS_MESSAGE_OCCUPANCYGRID_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_std_msgs/Header.h>
+#include <robot_nav_msgs/MapMetaData.h>
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct OccupancyGrid_
+{
+  typedef OccupancyGrid_<ContainerAllocator> Type;
+
+  OccupancyGrid_()
+    : header()
+    , info()
+    , data()  {
+    }
+  OccupancyGrid_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , info(_alloc)
+    , data(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::robot_std_msgs::Header  _header_type;
+  _header_type header;
+
+   typedef  ::robot_nav_msgs::MapMetaData_<ContainerAllocator>  _info_type;
+  _info_type info;
+
+   typedef std::vector<int8_t, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<int8_t>> _data_type;
+  _data_type data;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::OccupancyGrid_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::OccupancyGrid_<ContainerAllocator> const> ConstPtr;
+
+}; // struct OccupancyGrid_
+
+typedef ::robot_nav_msgs::OccupancyGrid_<std::allocator<void> > OccupancyGrid;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::OccupancyGrid > OccupancyGridPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::OccupancyGrid const> OccupancyGridConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::OccupancyGrid_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::OccupancyGrid_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.info == rhs.info &&
+    lhs.data == rhs.data;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::OccupancyGrid_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::OccupancyGrid_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // ROBOT_NAV_MSGS_MESSAGE_OCCUPANCYGRID_H

robot_nav_msgs/include/robot_nav_msgs/Odometry.h

@@ -0,0 +1,83 @@
+// Generated by gencpp from file robot_nav_msgs/Odometry.msg
+// DO NOT EDIT!
+
+
+#ifndef ROBOT_NAV_MSGS_MESSAGE_ODOMETRY_H
+#define ROBOT_NAV_MSGS_MESSAGE_ODOMETRY_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_std_msgs/Header.h>
+#include <robot_geometry_msgs/PoseWithCovariance.h>
+#include <robot_geometry_msgs/TwistWithCovariance.h>
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct Odometry_
+{
+  typedef Odometry_<ContainerAllocator> Type;
+
+  Odometry_()
+    : header()
+    , child_frame_id()
+    , pose()
+    , twist()  {
+    }
+  Odometry_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , child_frame_id(_alloc)
+    , pose(_alloc)
+    , twist(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::robot_std_msgs::Header  _header_type;
+  _header_type header;
+
+   typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _child_frame_id_type;
+  _child_frame_id_type child_frame_id;
+
+   typedef  ::robot_geometry_msgs::PoseWithCovariance  _pose_type;
+  _pose_type pose;
+
+   typedef  ::robot_geometry_msgs::TwistWithCovariance  _twist_type;
+  _twist_type twist;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::Odometry_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::Odometry_<ContainerAllocator> const> ConstPtr;
+
+}; // struct Odometry_
+
+typedef ::robot_nav_msgs::Odometry_<std::allocator<void> > Odometry;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::Odometry > OdometryPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::Odometry const> OdometryConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::Odometry_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::Odometry_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.child_frame_id == rhs.child_frame_id &&
+    lhs.pose == rhs.pose &&
+    lhs.twist == rhs.twist;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::Odometry_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::Odometry_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // ROBOT_NAV_MSGS_MESSAGE_ODOMETRY_H

robot_nav_msgs/include/robot_nav_msgs/Path.h

@@ -0,0 +1,70 @@
+// Generated by gencpp from file robot_nav_msgs/Path.msg
+// DO NOT EDIT!
+
+
+#ifndef ROBOT_NAV_MSGS_MESSAGE_PATH_H
+#define ROBOT_NAV_MSGS_MESSAGE_PATH_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_std_msgs/Header.h>
+#include <robot_geometry_msgs/PoseStamped.h>
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct Path_
+{
+  typedef Path_<ContainerAllocator> Type;
+
+  Path_()
+    : header()
+    , poses()  {
+    }
+  Path_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , poses(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::robot_std_msgs::Header  _header_type;
+  _header_type header;
+
+   typedef std::vector< ::robot_geometry_msgs::PoseStamped , typename std::allocator_traits<ContainerAllocator>::template rebind_alloc< ::robot_geometry_msgs::PoseStamped >> _poses_type;
+  _poses_type poses;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::Path_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::Path_<ContainerAllocator> const> ConstPtr;
+
+}; // struct Path_
+
+typedef ::robot_nav_msgs::Path_<std::allocator<void> > Path;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::Path > PathPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::Path const> PathConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::Path_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::Path_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.poses == rhs.poses;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::Path_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::Path_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // ROBOT_NAV_MSGS_MESSAGE_PATH_H

robot_nav_msgs/include/robot_nav_msgs/SetMap.h

@@ -0,0 +1,30 @@
+// Generated by gencpp from file robot_nav_msgs/SetMap.msg
+// DO NOT EDIT!
+
+
+#ifndef ROBOT_NAV_MSGS_MESSAGE_SETMAP_H
+#define ROBOT_NAV_MSGS_MESSAGE_SETMAP_H
+
+
+#include <robot_nav_msgs/SetMapRequest.h>
+#include <robot_nav_msgs/SetMapResponse.h>
+
+
+namespace robot_nav_msgs
+{
+
+struct SetMap
+{
+
+typedef SetMapRequest Request;
+typedef SetMapResponse Response;
+Request request;
+Response response;
+
+typedef Request RequestType;
+typedef Response ResponseType;
+
+}; // struct SetMap
+} // namespace robot_nav_msgs
+
+#endif // ROBOT_NAV_MSGS_MESSAGE_SETMAP_H

robot_nav_msgs/include/robot_nav_msgs/SetMapRequest.h

@@ -0,0 +1,70 @@
+// Generated by gencpp from file robot_nav_msgs/SetMapRequest.msg
+// DO NOT EDIT!
+
+
+#ifndef ROBOT_NAV_MSGS_MESSAGE_SETMAPREQUEST_H
+#define ROBOT_NAV_MSGS_MESSAGE_SETMAPREQUEST_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_nav_msgs/OccupancyGrid.h>
+#include <robot_geometry_msgs/PoseWithCovarianceStamped.h>
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct SetMapRequest_
+{
+  typedef SetMapRequest_<ContainerAllocator> Type;
+
+  SetMapRequest_()
+    : map()
+    , initial_pose()  {
+    }
+  SetMapRequest_(const ContainerAllocator& _alloc)
+    : map(_alloc)
+    , initial_pose(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::robot_nav_msgs::OccupancyGrid_<ContainerAllocator>  _map_type;
+  _map_type map;
+
+   typedef  ::robot_geometry_msgs::PoseWithCovarianceStamped  _initial_pose_type;
+  _initial_pose_type initial_pose;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::SetMapRequest_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::SetMapRequest_<ContainerAllocator> const> ConstPtr;
+
+}; // struct SetMapRequest_
+
+typedef ::robot_nav_msgs::SetMapRequest_<std::allocator<void> > SetMapRequest;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::SetMapRequest > SetMapRequestPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::SetMapRequest const> SetMapRequestConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::SetMapRequest_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::SetMapRequest_<ContainerAllocator2> & rhs)
+{
+  return lhs.map == rhs.map &&
+    lhs.initial_pose == rhs.initial_pose;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::SetMapRequest_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::SetMapRequest_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // ROBOT_NAV_MSGS_MESSAGE_SETMAPREQUEST_H

robot_nav_msgs/include/robot_nav_msgs/SetMapResponse.h

@@ -0,0 +1,62 @@
+// Generated by gencpp from file robot_nav_msgs/SetMapResponse.msg
+// DO NOT EDIT!
+
+
+#ifndef ROBOT_NAV_MSGS_MESSAGE_SETMAPRESPONSE_H
+#define ROBOT_NAV_MSGS_MESSAGE_SETMAPRESPONSE_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct SetMapResponse_
+{
+  typedef SetMapResponse_<ContainerAllocator> Type;
+
+  SetMapResponse_()
+    : success(false)  {
+    }
+  SetMapResponse_(const ContainerAllocator& _alloc)
+    : success(false)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef uint8_t _success_type;
+  _success_type success;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::SetMapResponse_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::SetMapResponse_<ContainerAllocator> const> ConstPtr;
+
+}; // struct SetMapResponse_
+
+typedef ::robot_nav_msgs::SetMapResponse_<std::allocator<void> > SetMapResponse;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::SetMapResponse > SetMapResponsePtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::SetMapResponse const> SetMapResponseConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::SetMapResponse_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::SetMapResponse_<ContainerAllocator2> & rhs)
+{
+  return lhs.success == rhs.success;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::SetMapResponse_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::SetMapResponse_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // ROBOT_NAV_MSGS_MESSAGE_SETMAPRESPONSE_H

robot_nav_msgs/package.xml

@@ -0,0 +1,27 @@
+<package>
+  <name>robot_nav_msgs</name>
+  <version>0.7.10</version>
+  <description>
+    robot_nav_msgs is the second generation of the transform library, which lets
+    the user keep track of multiple coordinate frames over time. robot_nav_msgs
+    maintains the relationship between coordinate frames in a tree
+    structure buffered in time, and lets the user transform points,
+    vectors, etc between any two coordinate frames at any desired
+    point in time.
+  </description>
+  <author>Tully Foote</author>
+  <author>Eitan Marder-Eppstein</author>
+  <author>Wim Meeussen</author>
+  <maintainer email="tfoote@osrfoundation.org">Tully Foote</maintainer>
+  <license>BSD</license>
+
+  <url type="website">http://www.ros.org/wiki/robot_nav_msgs</url>
+    
+  <buildtool_depend version_gte="0.5.68">catkin</buildtool_depend>
+
+  <build_depend>robot_std_msgs</build_depend>
+  <build_depend>robot_geometry_msgs</build_depend>
+
+  <run_depend>robot_std_msgs</run_depend>
+  <run_depend>robot_geometry_msgs</run_depend>
+</package>

robot_nav_msgs/test/CMakeCache.txt

@@ -0,0 +1,442 @@
+# This is the CMakeCache file.
+# For build in directory: /home/duongtd/robotics_core/common_msgs/robot_nav_msgs/test
+# It was generated by CMake: /usr/bin/cmake
+# You can edit this file to change values found and used by cmake.
+# If you do not want to change any of the values, simply exit the editor.
+# If you do want to change a value, simply edit, save, and exit the editor.
+# The syntax for the file is as follows:
+# KEY:TYPE=VALUE
+# KEY is the name of a variable in the cache.
+# TYPE is a hint to GUIs for the type of VALUE, DO NOT EDIT TYPE!.
+# VALUE is the current value for the KEY.
+
+########################
+# EXTERNAL cache entries
+########################
+
+//Path to a program.
+CMAKE_ADDR2LINE:FILEPATH=/usr/bin/addr2line
+
+//Path to a program.
+CMAKE_AR:FILEPATH=/usr/bin/ar
+
+//Choose the type of build, options are: None Debug Release RelWithDebInfo
+// MinSizeRel ...
+CMAKE_BUILD_TYPE:STRING=
+
+//Enable/Disable color output during build.
+CMAKE_COLOR_MAKEFILE:BOOL=ON
+
+//CXX compiler
+CMAKE_CXX_COMPILER:FILEPATH=/usr/bin/c++
+
+//A wrapper around 'ar' adding the appropriate '--plugin' option
+// for the GCC compiler
+CMAKE_CXX_COMPILER_AR:FILEPATH=/usr/bin/gcc-ar-9
+
+//A wrapper around 'ranlib' adding the appropriate '--plugin' option
+// for the GCC compiler
+CMAKE_CXX_COMPILER_RANLIB:FILEPATH=/usr/bin/gcc-ranlib-9
+
+//Flags used by the CXX compiler during all build types.
+CMAKE_CXX_FLAGS:STRING=
+
+//Flags used by the CXX compiler during DEBUG builds.
+CMAKE_CXX_FLAGS_DEBUG:STRING=-g
+
+//Flags used by the CXX compiler during MINSIZEREL builds.
+CMAKE_CXX_FLAGS_MINSIZEREL:STRING=-Os -DNDEBUG
+
+//Flags used by the CXX compiler during RELEASE builds.
+CMAKE_CXX_FLAGS_RELEASE:STRING=-O3 -DNDEBUG
+
+//Flags used by the CXX compiler during RELWITHDEBINFO builds.
+CMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG
+
+//C compiler
+CMAKE_C_COMPILER:FILEPATH=/usr/bin/cc
+
+//A wrapper around 'ar' adding the appropriate '--plugin' option
+// for the GCC compiler
+CMAKE_C_COMPILER_AR:FILEPATH=/usr/bin/gcc-ar-9
+
+//A wrapper around 'ranlib' adding the appropriate '--plugin' option
+// for the GCC compiler
+CMAKE_C_COMPILER_RANLIB:FILEPATH=/usr/bin/gcc-ranlib-9
+
+//Flags used by the C compiler during all build types.
+CMAKE_C_FLAGS:STRING=
+
+//Flags used by the C compiler during DEBUG builds.
+CMAKE_C_FLAGS_DEBUG:STRING=-g
+
+//Flags used by the C compiler during MINSIZEREL builds.
+CMAKE_C_FLAGS_MINSIZEREL:STRING=-Os -DNDEBUG
+
+//Flags used by the C compiler during RELEASE builds.
+CMAKE_C_FLAGS_RELEASE:STRING=-O3 -DNDEBUG
+
+//Flags used by the C compiler during RELWITHDEBINFO builds.
+CMAKE_C_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG
+
+//Path to a program.
+CMAKE_DLLTOOL:FILEPATH=CMAKE_DLLTOOL-NOTFOUND
+
+//Flags used by the linker during all build types.
+CMAKE_EXE_LINKER_FLAGS:STRING=
+
+//Flags used by the linker during DEBUG builds.
+CMAKE_EXE_LINKER_FLAGS_DEBUG:STRING=
+
+//Flags used by the linker during MINSIZEREL builds.
+CMAKE_EXE_LINKER_FLAGS_MINSIZEREL:STRING=
+
+//Flags used by the linker during RELEASE builds.
+CMAKE_EXE_LINKER_FLAGS_RELEASE:STRING=
+
+//Flags used by the linker during RELWITHDEBINFO builds.
+CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO:STRING=
+
+//Enable/Disable output of compile commands during generation.
+CMAKE_EXPORT_COMPILE_COMMANDS:BOOL=OFF
+
+//Install path prefix, prepended onto install directories.
+CMAKE_INSTALL_PREFIX:PATH=/usr/local
+
+//Path to a program.
+CMAKE_LINKER:FILEPATH=/usr/bin/ld
+
+//Path to a program.
+CMAKE_MAKE_PROGRAM:FILEPATH=/usr/bin/make
+
+//Flags used by the linker during the creation of modules during
+// all build types.
+CMAKE_MODULE_LINKER_FLAGS:STRING=
+
+//Flags used by the linker during the creation of modules during
+// DEBUG builds.
+CMAKE_MODULE_LINKER_FLAGS_DEBUG:STRING=
+
+//Flags used by the linker during the creation of modules during
+// MINSIZEREL builds.
+CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL:STRING=
+
+//Flags used by the linker during the creation of modules during
+// RELEASE builds.
+CMAKE_MODULE_LINKER_FLAGS_RELEASE:STRING=
+
+//Flags used by the linker during the creation of modules during
+// RELWITHDEBINFO builds.
+CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO:STRING=
+
+//Path to a program.
+CMAKE_NM:FILEPATH=/usr/bin/nm
+
+//Path to a program.
+CMAKE_OBJCOPY:FILEPATH=/usr/bin/objcopy
+
+//Path to a program.
+CMAKE_OBJDUMP:FILEPATH=/usr/bin/objdump
+
+//Value Computed by CMake
+CMAKE_PROJECT_DESCRIPTION:STATIC=
+
+//Value Computed by CMake
+CMAKE_PROJECT_HOMEPAGE_URL:STATIC=
+
+//Value Computed by CMake
+CMAKE_PROJECT_NAME:STATIC=robot_nav_msgs
+
+//Path to a program.
+CMAKE_RANLIB:FILEPATH=/usr/bin/ranlib
+
+//Path to a program.
+CMAKE_READELF:FILEPATH=/usr/bin/readelf
+
+//Flags used by the linker during the creation of shared libraries
+// during all build types.
+CMAKE_SHARED_LINKER_FLAGS:STRING=
+
+//Flags used by the linker during the creation of shared libraries
+// during DEBUG builds.
+CMAKE_SHARED_LINKER_FLAGS_DEBUG:STRING=
+
+//Flags used by the linker during the creation of shared libraries
+// during MINSIZEREL builds.
+CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL:STRING=
+
+//Flags used by the linker during the creation of shared libraries
+// during RELEASE builds.
+CMAKE_SHARED_LINKER_FLAGS_RELEASE:STRING=
+
+//Flags used by the linker during the creation of shared libraries
+// during RELWITHDEBINFO builds.
+CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO:STRING=
+
+//If set, runtime paths are not added when installing shared libraries,
+// but are added when building.
+CMAKE_SKIP_INSTALL_RPATH:BOOL=NO
+
+//If set, runtime paths are not added when using shared libraries.
+CMAKE_SKIP_RPATH:BOOL=NO
+
+//Flags used by the linker during the creation of static libraries
+// during all build types.
+CMAKE_STATIC_LINKER_FLAGS:STRING=
+
+//Flags used by the linker during the creation of static libraries
+// during DEBUG builds.
+CMAKE_STATIC_LINKER_FLAGS_DEBUG:STRING=
+
+//Flags used by the linker during the creation of static libraries
+// during MINSIZEREL builds.
+CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL:STRING=
+
+//Flags used by the linker during the creation of static libraries
+// during RELEASE builds.
+CMAKE_STATIC_LINKER_FLAGS_RELEASE:STRING=
+
+//Flags used by the linker during the creation of static libraries
+// during RELWITHDEBINFO builds.
+CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO:STRING=
+
+//Path to a program.
+CMAKE_STRIP:FILEPATH=/usr/bin/strip
+
+//If this value is on, makefiles will be generated without the
+// .SILENT directive, and all commands will be echoed to the console
+// during the make.  This is useful for debugging only. With Visual
+// Studio IDE projects all commands are done without /nologo.
+CMAKE_VERBOSE_MAKEFILE:BOOL=FALSE
+
+//Path to a library.
+GMOCK_LIBRARY:FILEPATH=/usr/local/lib/libgmock.a
+
+//Path to a library.
+GMOCK_LIBRARY_DEBUG:FILEPATH=GMOCK_LIBRARY_DEBUG-NOTFOUND
+
+//Path to a library.
+GMOCK_MAIN_LIBRARY:FILEPATH=/usr/local/lib/libgmock_main.a
+
+//Path to a library.
+GMOCK_MAIN_LIBRARY_DEBUG:FILEPATH=GMOCK_MAIN_LIBRARY_DEBUG-NOTFOUND
+
+//Path to a file.
+GTEST_INCLUDE_DIR:PATH=/usr/local/include
+
+//Path to a library.
+GTEST_LIBRARY:FILEPATH=/usr/local/lib/libgtest.a
+
+//Path to a library.
+GTEST_LIBRARY_DEBUG:FILEPATH=GTEST_LIBRARY_DEBUG-NOTFOUND
+
+//Path to a library.
+GTEST_MAIN_LIBRARY:FILEPATH=/usr/local/lib/libgtest_main.a
+
+//Path to a library.
+GTEST_MAIN_LIBRARY_DEBUG:FILEPATH=GTEST_MAIN_LIBRARY_DEBUG-NOTFOUND
+
+//The directory containing a CMake configuration file for GTest.
+GTest_DIR:PATH=GTest_DIR-NOTFOUND
+
+//Value Computed by CMake
+geometry_msgs_BINARY_DIR:STATIC=/home/duongtd/robotics_core/common_msgs/robot_nav_msgs/test/geometry_msgs_build
+
+//Value Computed by CMake
+geometry_msgs_SOURCE_DIR:STATIC=/home/duongtd/robotics_core/common_msgs/geometry_msgs
+
+//Value Computed by CMake
+robot_nav_msgs_BINARY_DIR:STATIC=/home/duongtd/robotics_core/common_msgs/robot_nav_msgs/test
+
+//Value Computed by CMake
+robot_nav_msgs_SOURCE_DIR:STATIC=/home/duongtd/robotics_core/common_msgs/robot_nav_msgs
+
+//Value Computed by CMake
+robot_time_BINARY_DIR:STATIC=/home/duongtd/robotics_core/common_msgs/robot_nav_msgs/test/robot_time_build
+
+//Value Computed by CMake
+robot_time_SOURCE_DIR:STATIC=/home/duongtd/robotics_core/robot_time
+
+//Value Computed by CMake
+robot_std_msgs_BINARY_DIR:STATIC=/home/duongtd/robotics_core/common_msgs/robot_nav_msgs/test/robot_std_msgs_build
+
+//Value Computed by CMake
+robot_std_msgs_SOURCE_DIR:STATIC=/home/duongtd/robotics_core/common_msgs/robot_std_msgs
+
+
+########################
+# INTERNAL cache entries
+########################
+
+//ADVANCED property for variable: CMAKE_ADDR2LINE
+CMAKE_ADDR2LINE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_AR
+CMAKE_AR-ADVANCED:INTERNAL=1
+//This is the directory where this CMakeCache.txt was created
+CMAKE_CACHEFILE_DIR:INTERNAL=/home/duongtd/robotics_core/common_msgs/robot_nav_msgs/test
+//Major version of cmake used to create the current loaded cache
+CMAKE_CACHE_MAJOR_VERSION:INTERNAL=3
+//Minor version of cmake used to create the current loaded cache
+CMAKE_CACHE_MINOR_VERSION:INTERNAL=16
+//Patch version of cmake used to create the current loaded cache
+CMAKE_CACHE_PATCH_VERSION:INTERNAL=3
+//ADVANCED property for variable: CMAKE_COLOR_MAKEFILE
+CMAKE_COLOR_MAKEFILE-ADVANCED:INTERNAL=1
+//Path to CMake executable.
+CMAKE_COMMAND:INTERNAL=/usr/bin/cmake
+//Path to cpack program executable.
+CMAKE_CPACK_COMMAND:INTERNAL=/usr/bin/cpack
+//Path to ctest program executable.
+CMAKE_CTEST_COMMAND:INTERNAL=/usr/bin/ctest
+//ADVANCED property for variable: CMAKE_CXX_COMPILER
+CMAKE_CXX_COMPILER-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_COMPILER_AR
+CMAKE_CXX_COMPILER_AR-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_COMPILER_RANLIB
+CMAKE_CXX_COMPILER_RANLIB-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_FLAGS
+CMAKE_CXX_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_FLAGS_DEBUG
+CMAKE_CXX_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_FLAGS_MINSIZEREL
+CMAKE_CXX_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELEASE
+CMAKE_CXX_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELWITHDEBINFO
+CMAKE_CXX_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_COMPILER
+CMAKE_C_COMPILER-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_COMPILER_AR
+CMAKE_C_COMPILER_AR-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_COMPILER_RANLIB
+CMAKE_C_COMPILER_RANLIB-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_FLAGS
+CMAKE_C_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_FLAGS_DEBUG
+CMAKE_C_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_FLAGS_MINSIZEREL
+CMAKE_C_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_FLAGS_RELEASE
+CMAKE_C_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_FLAGS_RELWITHDEBINFO
+CMAKE_C_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_DLLTOOL
+CMAKE_DLLTOOL-ADVANCED:INTERNAL=1
+//Executable file format
+CMAKE_EXECUTABLE_FORMAT:INTERNAL=ELF
+//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS
+CMAKE_EXE_LINKER_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_DEBUG
+CMAKE_EXE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_MINSIZEREL
+CMAKE_EXE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELEASE
+CMAKE_EXE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO
+CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_EXPORT_COMPILE_COMMANDS
+CMAKE_EXPORT_COMPILE_COMMANDS-ADVANCED:INTERNAL=1
+//Name of external makefile project generator.
+CMAKE_EXTRA_GENERATOR:INTERNAL=
+//Name of generator.
+CMAKE_GENERATOR:INTERNAL=Unix Makefiles
+//Generator instance identifier.
+CMAKE_GENERATOR_INSTANCE:INTERNAL=
+//Name of generator platform.
+CMAKE_GENERATOR_PLATFORM:INTERNAL=
+//Name of generator toolset.
+CMAKE_GENERATOR_TOOLSET:INTERNAL=
+//Test CMAKE_HAVE_LIBC_PTHREAD
+CMAKE_HAVE_LIBC_PTHREAD:INTERNAL=
+//Have library pthreads
+CMAKE_HAVE_PTHREADS_CREATE:INTERNAL=
+//Have library pthread
+CMAKE_HAVE_PTHREAD_CREATE:INTERNAL=1
+//Have include pthread.h
+CMAKE_HAVE_PTHREAD_H:INTERNAL=1
+//Source directory with the top level CMakeLists.txt file for this
+// project
+CMAKE_HOME_DIRECTORY:INTERNAL=/home/duongtd/robotics_core/common_msgs/robot_nav_msgs
+//Install .so files without execute permission.
+CMAKE_INSTALL_SO_NO_EXE:INTERNAL=1
+//ADVANCED property for variable: CMAKE_LINKER
+CMAKE_LINKER-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MAKE_PROGRAM
+CMAKE_MAKE_PROGRAM-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS
+CMAKE_MODULE_LINKER_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_DEBUG
+CMAKE_MODULE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL
+CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELEASE
+CMAKE_MODULE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO
+CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_NM
+CMAKE_NM-ADVANCED:INTERNAL=1
+//number of local generators
+CMAKE_NUMBER_OF_MAKEFILES:INTERNAL=4
+//ADVANCED property for variable: CMAKE_OBJCOPY
+CMAKE_OBJCOPY-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_OBJDUMP
+CMAKE_OBJDUMP-ADVANCED:INTERNAL=1
+//Platform information initialized
+CMAKE_PLATFORM_INFO_INITIALIZED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_RANLIB
+CMAKE_RANLIB-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_READELF
+CMAKE_READELF-ADVANCED:INTERNAL=1
+//Path to CMake installation.
+CMAKE_ROOT:INTERNAL=/usr/share/cmake-3.16
+//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS
+CMAKE_SHARED_LINKER_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_DEBUG
+CMAKE_SHARED_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL
+CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELEASE
+CMAKE_SHARED_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO
+CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SKIP_INSTALL_RPATH
+CMAKE_SKIP_INSTALL_RPATH-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SKIP_RPATH
+CMAKE_SKIP_RPATH-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS
+CMAKE_STATIC_LINKER_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_DEBUG
+CMAKE_STATIC_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL
+CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELEASE
+CMAKE_STATIC_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO
+CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STRIP
+CMAKE_STRIP-ADVANCED:INTERNAL=1
+//uname command
+CMAKE_UNAME:INTERNAL=/usr/bin/uname
+//ADVANCED property for variable: CMAKE_VERBOSE_MAKEFILE
+CMAKE_VERBOSE_MAKEFILE-ADVANCED:INTERNAL=1
+//Details about finding GTest
+FIND_PACKAGE_MESSAGE_DETAILS_GTest:INTERNAL=[/usr/local/lib/libgtest.a][/usr/local/include][/usr/local/lib/libgtest_main.a][v()]
+//ADVANCED property for variable: GMOCK_LIBRARY
+GMOCK_LIBRARY-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: GMOCK_LIBRARY_DEBUG
+GMOCK_LIBRARY_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: GMOCK_MAIN_LIBRARY
+GMOCK_MAIN_LIBRARY-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: GMOCK_MAIN_LIBRARY_DEBUG
+GMOCK_MAIN_LIBRARY_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: GTEST_INCLUDE_DIR
+GTEST_INCLUDE_DIR-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: GTEST_LIBRARY
+GTEST_LIBRARY-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: GTEST_LIBRARY_DEBUG
+GTEST_LIBRARY_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: GTEST_MAIN_LIBRARY
+GTEST_MAIN_LIBRARY-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: GTEST_MAIN_LIBRARY_DEBUG
+GTEST_MAIN_LIBRARY_DEBUG-ADVANCED:INTERNAL=1
+