carto_slam,amcl,laser_scan_matcher,sick561

.catkin_workspace

@@ -0,0 +1 @@
+# This file currently only serves to mark the location of a catkin workspace for tool integration

.gitignore

@@ -0,0 +1,34 @@
+
+#Ignore thumbnails created by Windows
+Thumbs.db
+#Ignore files built by Visual Studio
+*.obj
+*.exe
+*.pdb
+*.user
+*.aps
+*.pch
+*.vspscc
+*_i.c
+*_p.c
+*.ncb
+*.suo
+*.tlb
+*.tlh
+*.bak
+*.cache
+*.ilk
+*.log
+[Bb]in
+[Dd]ebug*/
+[Bb]uild*/
+*.lib
+*.sbr
+obj/
+[Rr]elease*/
+_ReSharper*/
+[Tt]est[Rr]esult*
+.vs/
+.vscode/
+#Nuget packages folder
+packages/

demo_sick.launch

@@ -0,0 +1,19 @@
+<launch>
+  <param name="/use_sim_time" value="false" />
+
+  <node name="cartographer_node" pkg="cartographer_ros"
+      type="cartographer_node" args="
+      -configuration_directory $(find cartographer_ros)/configuration_files
+      -configuration_basename demo_sick.lua"
+      output="screen">
+	  
+  </node>
+
+    <!-->
+  <node name="cartographer_occupancy_grid_node" pkg="cartographer_ros"
+      type="cartographer_occupancy_grid_node" args="-resolution 0.05" />
+<-->
+  <node name="rviz" pkg="rviz" type="rviz" required="true"
+      args="-d $(find cartographer_ros)/configuration_files/demo_sick.rviz" />
+
+</launch>

demo_sick.lua

@@ -0,0 +1,43 @@
+
+include "map_builder.lua"
+include "trajectory_builder.lua"
+
+options = {
+  map_builder = MAP_BUILDER,
+  trajectory_builder = TRAJECTORY_BUILDER,
+  map_frame = "map",
+  tracking_frame = "laser",
+  published_frame = "laser",
+  odom_frame = "odom",
+  provide_odom_frame = false,
+  publish_frame_projected_to_2d = false,
+  use_pose_extrapolator = true,
+  use_odometry = false,
+  use_nav_sat = false,
+  use_landmarks = false,
+  num_laser_scans = 1,
+  num_multi_echo_laser_scans = 0,
+  num_subdivisions_per_laser_scan = 1,
+  num_point_clouds = 0,
+  lookup_transform_timeout_sec = 0.2,
+  submap_publish_period_sec = 0.3,
+  pose_publish_period_sec = 3e-2,
+  trajectory_publish_period_sec = 3e-2,
+  rangefinder_sampling_ratio = 1.,
+  odometry_sampling_ratio = 1.,
+  fixed_frame_pose_sampling_ratio = 1.,
+  imu_sampling_ratio = 1.,
+  landmarks_sampling_ratio = 1.,
+}
+
+MAP_BUILDER.num_background_threads=6
+MAP_BUILDER.use_trajectory_builder_2d = true
+
+TRAJECTORY_BUILDER_2D.use_online_correlative_scan_matching = true
+TRAJECTORY_BUILDER_2D.use_imu_data = false
+TRAJECTORY_BUILDER_2D.real_time_correlative_scan_matcher.linear_search_window = 0.15
+TRAJECTORY_BUILDER_2D.real_time_correlative_scan_matcher.angular_search_window = math.rad(35.)
+
+POSE_GRAPH.optimization_problem.huber_scale = 1e2
+
+return options

demo_sick_location.lua

@@ -0,0 +1,61 @@
+-- Copyright 2016 The Cartographer Authors
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--      http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+
+include "map_builder.lua"
+include "trajectory_builder.lua"
+
+options = {
+  map_builder = MAP_BUILDER,
+  trajectory_builder = TRAJECTORY_BUILDER,
+  map_frame = "map",
+  tracking_frame = "laser",
+  published_frame = "laser",
+  odom_frame = "odom",
+  provide_odom_frame = false,
+  publish_frame_projected_to_2d = false,
+  use_pose_extrapolator = true,
+  use_odometry = false,
+  use_nav_sat = false,
+  use_landmarks = false,
+  num_laser_scans = 1,
+  num_multi_echo_laser_scans = 0,
+  num_subdivisions_per_laser_scan = 1,
+  num_point_clouds = 0,
+  lookup_transform_timeout_sec = 0.2,
+  submap_publish_period_sec = 0.3,
+  pose_publish_period_sec = 3e-2,
+  trajectory_publish_period_sec = 3e-2,
+  rangefinder_sampling_ratio = 1.,
+  odometry_sampling_ratio = 1.,
+  fixed_frame_pose_sampling_ratio = 1.,
+  imu_sampling_ratio = 1.,
+  landmarks_sampling_ratio = 1.,
+}
+
+MAP_BUILDER.num_background_threads=6
+MAP_BUILDER.use_trajectory_builder_2d = true
+
+TRAJECTORY_BUILDER_2D.use_online_correlative_scan_matching = true
+TRAJECTORY_BUILDER_2D.use_imu_data = false
+TRAJECTORY_BUILDER_2D.real_time_correlative_scan_matcher.linear_search_window = 0.15
+TRAJECTORY_BUILDER_2D.real_time_correlative_scan_matcher.angular_search_window = math.rad(35.)
+
+POSE_GRAPH.optimization_problem.huber_scale = 1e2
+
+TRAJECTORY_BUILDER.pure_localization_trimmer = {
+  max_submaps_to_keep = 3,
+}
+POSE_GRAPH.optimize_every_n_nodes = 10
+
+return options

devel/.built_by

@@ -0,0 +1 @@
+catkin_make

devel/.catkin

@@ -0,0 +1 @@
+/home/youchen/Documents/catkin_ws/src

devel/.rosinstall

@@ -0,0 +1,2 @@
+- setup-file:
+    local-name: /home/youchen/Documents/catkin_ws/devel/setup.sh

devel/_setup_util.py

@@ -0,0 +1,290 @@
+#!/usr/bin/python2
+# -*- coding: utf-8 -*-
+
+# Software License Agreement (BSD License)
+#
+# Copyright (c) 2012, Willow Garage, Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+#  * Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+#  * Redistributions in binary form must reproduce the above
+#    copyright notice, this list of conditions and the following
+#    disclaimer in the documentation and/or other materials provided
+#    with the distribution.
+#  * Neither the name of Willow Garage, Inc. nor the names of its
+#    contributors may be used to endorse or promote products derived
+#    from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+'''This file generates shell code for the setup.SHELL scripts to set environment variables'''
+
+from __future__ import print_function
+import argparse
+import copy
+import errno
+import os
+import platform
+import sys
+
+CATKIN_MARKER_FILE = '.catkin'
+
+system = platform.system()
+IS_DARWIN = (system == 'Darwin')
+IS_WINDOWS = (system == 'Windows')
+
+# subfolder of workspace prepended to CMAKE_PREFIX_PATH
+ENV_VAR_SUBFOLDERS = {
+    'CMAKE_PREFIX_PATH': '',
+    'LD_LIBRARY_PATH' if not IS_DARWIN else 'DYLD_LIBRARY_PATH': ['lib', os.path.join('lib', 'x86_64-linux-gnu')],
+    'PATH': 'bin',
+    'PKG_CONFIG_PATH': [os.path.join('lib', 'pkgconfig'), os.path.join('lib', 'x86_64-linux-gnu', 'pkgconfig')],
+    'PYTHONPATH': 'lib/python2.7/dist-packages',
+}
+
+
+def rollback_env_variables(environ, env_var_subfolders):
+    '''
+    Generate shell code to reset environment variables
+    by unrolling modifications based on all workspaces in CMAKE_PREFIX_PATH.
+    This does not cover modifications performed by environment hooks.
+    '''
+    lines = []
+    unmodified_environ = copy.copy(environ)
+    for key in sorted(env_var_subfolders.keys()):
+        subfolders = env_var_subfolders[key]
+        if not isinstance(subfolders, list):
+            subfolders = [subfolders]
+        value = _rollback_env_variable(unmodified_environ, key, subfolders)
+        if value is not None:
+            environ[key] = value
+            lines.append(assignment(key, value))
+    if lines:
+        lines.insert(0, comment('reset environment variables by unrolling modifications based on all workspaces in CMAKE_PREFIX_PATH'))
+    return lines
+
+
+def _rollback_env_variable(environ, name, subfolders):
+    '''
+    For each catkin workspace in CMAKE_PREFIX_PATH remove the first entry from env[NAME] matching workspace + subfolder.
+
+    :param subfolders: list of str '' or subfoldername that may start with '/'
+    :returns: the updated value of the environment variable.
+    '''
+    value = environ[name] if name in environ else ''
+    env_paths = [path for path in value.split(os.pathsep) if path]
+    value_modified = False
+    for subfolder in subfolders:
+        if subfolder:
+            if subfolder.startswith(os.path.sep) or (os.path.altsep and subfolder.startswith(os.path.altsep)):
+                subfolder = subfolder[1:]
+            if subfolder.endswith(os.path.sep) or (os.path.altsep and subfolder.endswith(os.path.altsep)):
+                subfolder = subfolder[:-1]
+        for ws_path in _get_workspaces(environ, include_fuerte=True, include_non_existing=True):
+            path_to_find = os.path.join(ws_path, subfolder) if subfolder else ws_path
+            path_to_remove = None
+            for env_path in env_paths:
+                env_path_clean = env_path[:-1] if env_path and env_path[-1] in [os.path.sep, os.path.altsep] else env_path
+                if env_path_clean == path_to_find:
+                    path_to_remove = env_path
+                    break
+            if path_to_remove:
+                env_paths.remove(path_to_remove)
+                value_modified = True
+    new_value = os.pathsep.join(env_paths)
+    return new_value if value_modified else None
+
+
+def _get_workspaces(environ, include_fuerte=False, include_non_existing=False):
+    '''
+    Based on CMAKE_PREFIX_PATH return all catkin workspaces.
+
+    :param include_fuerte: The flag if paths starting with '/opt/ros/fuerte' should be considered workspaces, ``bool``
+    '''
+    # get all cmake prefix paths
+    env_name = 'CMAKE_PREFIX_PATH'
+    value = environ[env_name] if env_name in environ else ''
+    paths = [path for path in value.split(os.pathsep) if path]
+    # remove non-workspace paths
+    workspaces = [path for path in paths if os.path.isfile(os.path.join(path, CATKIN_MARKER_FILE)) or (include_fuerte and path.startswith('/opt/ros/fuerte')) or (include_non_existing and not os.path.exists(path))]
+    return workspaces
+
+
+def prepend_env_variables(environ, env_var_subfolders, workspaces):
+    '''
+    Generate shell code to prepend environment variables
+    for the all workspaces.
+    '''
+    lines = []
+    lines.append(comment('prepend folders of workspaces to environment variables'))
+
+    paths = [path for path in workspaces.split(os.pathsep) if path]
+
+    prefix = _prefix_env_variable(environ, 'CMAKE_PREFIX_PATH', paths, '')
+    lines.append(prepend(environ, 'CMAKE_PREFIX_PATH', prefix))
+
+    for key in sorted([key for key in env_var_subfolders.keys() if key != 'CMAKE_PREFIX_PATH']):
+        subfolder = env_var_subfolders[key]
+        prefix = _prefix_env_variable(environ, key, paths, subfolder)
+        lines.append(prepend(environ, key, prefix))
+    return lines
+
+
+def _prefix_env_variable(environ, name, paths, subfolders):
+    '''
+    Return the prefix to prepend to the environment variable NAME, adding any path in NEW_PATHS_STR without creating duplicate or empty items.
+    '''
+    value = environ[name] if name in environ else ''
+    environ_paths = [path for path in value.split(os.pathsep) if path]
+    checked_paths = []
+    for path in paths:
+        if not isinstance(subfolders, list):
+            subfolders = [subfolders]
+        for subfolder in subfolders:
+            path_tmp = path
+            if subfolder:
+                path_tmp = os.path.join(path_tmp, subfolder)
+            # skip nonexistent paths
+            if not os.path.exists(path_tmp):
+                continue
+            # exclude any path already in env and any path we already added
+            if path_tmp not in environ_paths and path_tmp not in checked_paths:
+                checked_paths.append(path_tmp)
+    prefix_str = os.pathsep.join(checked_paths)
+    if prefix_str != '' and environ_paths:
+        prefix_str += os.pathsep
+    return prefix_str
+
+
+def assignment(key, value):
+    if not IS_WINDOWS:
+        return 'export %s="%s"' % (key, value)
+    else:
+        return 'set %s=%s' % (key, value)
+
+
+def comment(msg):
+    if not IS_WINDOWS:
+        return '# %s' % msg
+    else:
+        return 'REM %s' % msg
+
+
+def prepend(environ, key, prefix):
+    if key not in environ or not environ[key]:
+        return assignment(key, prefix)
+    if not IS_WINDOWS:
+        return 'export %s="%s$%s"' % (key, prefix, key)
+    else:
+        return 'set %s=%s%%%s%%' % (key, prefix, key)
+
+
+def find_env_hooks(environ, cmake_prefix_path):
+    '''
+    Generate shell code with found environment hooks
+    for the all workspaces.
+    '''
+    lines = []
+    lines.append(comment('found environment hooks in workspaces'))
+
+    generic_env_hooks = []
+    generic_env_hooks_workspace = []
+    specific_env_hooks = []
+    specific_env_hooks_workspace = []
+    generic_env_hooks_by_filename = {}
+    specific_env_hooks_by_filename = {}
+    generic_env_hook_ext = 'bat' if IS_WINDOWS else 'sh'
+    specific_env_hook_ext = environ['CATKIN_SHELL'] if not IS_WINDOWS and 'CATKIN_SHELL' in environ and environ['CATKIN_SHELL'] else None
+    # remove non-workspace paths
+    workspaces = [path for path in cmake_prefix_path.split(os.pathsep) if path and os.path.isfile(os.path.join(path, CATKIN_MARKER_FILE))]
+    for workspace in reversed(workspaces):
+        env_hook_dir = os.path.join(workspace, 'etc', 'catkin', 'profile.d')
+        if os.path.isdir(env_hook_dir):
+            for filename in sorted(os.listdir(env_hook_dir)):
+                if filename.endswith('.%s' % generic_env_hook_ext):
+                    # remove previous env hook with same name if present
+                    if filename in generic_env_hooks_by_filename:
+                        i = generic_env_hooks.index(generic_env_hooks_by_filename[filename])
+                        generic_env_hooks.pop(i)
+                        generic_env_hooks_workspace.pop(i)
+                    # append env hook
+                    generic_env_hooks.append(os.path.join(env_hook_dir, filename))
+                    generic_env_hooks_workspace.append(workspace)
+                    generic_env_hooks_by_filename[filename] = generic_env_hooks[-1]
+                elif specific_env_hook_ext is not None and filename.endswith('.%s' % specific_env_hook_ext):
+                    # remove previous env hook with same name if present
+                    if filename in specific_env_hooks_by_filename:
+                        i = specific_env_hooks.index(specific_env_hooks_by_filename[filename])
+                        specific_env_hooks.pop(i)
+                        specific_env_hooks_workspace.pop(i)
+                    # append env hook
+                    specific_env_hooks.append(os.path.join(env_hook_dir, filename))
+                    specific_env_hooks_workspace.append(workspace)
+                    specific_env_hooks_by_filename[filename] = specific_env_hooks[-1]
+    env_hooks = generic_env_hooks + specific_env_hooks
+    env_hooks_workspace = generic_env_hooks_workspace + specific_env_hooks_workspace
+    count = len(env_hooks)
+    lines.append(assignment('_CATKIN_ENVIRONMENT_HOOKS_COUNT', count))
+    for i in range(count):
+        lines.append(assignment('_CATKIN_ENVIRONMENT_HOOKS_%d' % i, env_hooks[i]))
+        lines.append(assignment('_CATKIN_ENVIRONMENT_HOOKS_%d_WORKSPACE' % i, env_hooks_workspace[i]))
+    return lines
+
+
+def _parse_arguments(args=None):
+    parser = argparse.ArgumentParser(description='Generates code blocks for the setup.SHELL script.')
+    parser.add_argument('--extend', action='store_true', help='Skip unsetting previous environment variables to extend context')
+    return parser.parse_known_args(args=args)[0]
+
+
+if __name__ == '__main__':
+    try:
+        try:
+            args = _parse_arguments()
+        except Exception as e:
+            print(e, file=sys.stderr)
+            sys.exit(1)
+
+        # environment at generation time
+        CMAKE_PREFIX_PATH = '/home/youchen/Documents/catkin_ws/devel;/opt/ros/melodic'.split(';')
+        # prepend current workspace if not already part of CPP
+        base_path = os.path.dirname(__file__)
+        if base_path not in CMAKE_PREFIX_PATH:
+            CMAKE_PREFIX_PATH.insert(0, base_path)
+        CMAKE_PREFIX_PATH = os.pathsep.join(CMAKE_PREFIX_PATH)
+
+        environ = dict(os.environ)
+        lines = []
+        if not args.extend:
+            lines += rollback_env_variables(environ, ENV_VAR_SUBFOLDERS)
+        lines += prepend_env_variables(environ, ENV_VAR_SUBFOLDERS, CMAKE_PREFIX_PATH)
+        lines += find_env_hooks(environ, CMAKE_PREFIX_PATH)
+        print('\n'.join(lines))
+
+        # need to explicitly flush the output
+        sys.stdout.flush()
+    except IOError as e:
+        # and catch potential "broken pipe" if stdout is not writable
+        # which can happen when piping the output to a file but the disk is full
+        if e.errno == errno.EPIPE:
+            print(e, file=sys.stderr)
+            sys.exit(2)
+        raise
+
+    sys.exit(0)

devel/env.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/env sh
+# generated from catkin/cmake/templates/env.sh.in
+
+if [ $# -eq 0 ] ; then
+  /bin/echo "Usage: env.sh COMMANDS"
+  /bin/echo "Calling env.sh without arguments is not supported anymore. Instead spawn a subshell and source a setup file manually."
+  exit 1
+fi
+
+# ensure to not use different shell type which was set before
+CATKIN_SHELL=sh
+
+# source setup.sh from same directory as this file
+_CATKIN_SETUP_DIR=$(cd "`dirname "$0"`" > /dev/null && pwd)
+. "$_CATKIN_SETUP_DIR/setup.sh"
+exec "$@"

devel/include/cartographer_ros_msgs/BagfileProgress.h

@@ -0,0 +1,257 @@
+// Generated by gencpp from file cartographer_ros_msgs/BagfileProgress.msg
+// DO NOT EDIT!
+
+
+#ifndef CARTOGRAPHER_ROS_MSGS_MESSAGE_BAGFILEPROGRESS_H
+#define CARTOGRAPHER_ROS_MSGS_MESSAGE_BAGFILEPROGRESS_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+
+namespace cartographer_ros_msgs
+{
+template <class ContainerAllocator>
+struct BagfileProgress_
+{
+  typedef BagfileProgress_<ContainerAllocator> Type;
+
+  BagfileProgress_()
+    : current_bagfile_name()
+    , current_bagfile_id(0)
+    , total_bagfiles(0)
+    , total_messages(0)
+    , processed_messages(0)
+    , total_seconds(0.0)
+    , processed_seconds(0.0)  {
+    }
+  BagfileProgress_(const ContainerAllocator& _alloc)
+    : current_bagfile_name(_alloc)
+    , current_bagfile_id(0)
+    , total_bagfiles(0)
+    , total_messages(0)
+    , processed_messages(0)
+    , total_seconds(0.0)
+    , processed_seconds(0.0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _current_bagfile_name_type;
+  _current_bagfile_name_type current_bagfile_name;
+
+   typedef uint32_t _current_bagfile_id_type;
+  _current_bagfile_id_type current_bagfile_id;
+
+   typedef uint32_t _total_bagfiles_type;
+  _total_bagfiles_type total_bagfiles;
+
+   typedef uint32_t _total_messages_type;
+  _total_messages_type total_messages;
+
+   typedef uint32_t _processed_messages_type;
+  _processed_messages_type processed_messages;
+
+   typedef float _total_seconds_type;
+  _total_seconds_type total_seconds;
+
+   typedef float _processed_seconds_type;
+  _processed_seconds_type processed_seconds;
+
+
+
+
+
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::BagfileProgress_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::BagfileProgress_<ContainerAllocator> const> ConstPtr;
+
+}; // struct BagfileProgress_
+
+typedef ::cartographer_ros_msgs::BagfileProgress_<std::allocator<void> > BagfileProgress;
+
+typedef boost::shared_ptr< ::cartographer_ros_msgs::BagfileProgress > BagfileProgressPtr;
+typedef boost::shared_ptr< ::cartographer_ros_msgs::BagfileProgress const> BagfileProgressConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::cartographer_ros_msgs::BagfileProgress_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::cartographer_ros_msgs::BagfileProgress_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace cartographer_ros_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'cartographer_ros_msgs': ['/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_ros_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::BagfileProgress_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::BagfileProgress_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::BagfileProgress_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::BagfileProgress_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::BagfileProgress_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::BagfileProgress_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::cartographer_ros_msgs::BagfileProgress_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "2a36f93b13e2b297d45098a38cb00510";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::BagfileProgress_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x2a36f93b13e2b297ULL;
+  static const uint64_t static_value2 = 0xd45098a38cb00510ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::cartographer_ros_msgs::BagfileProgress_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/BagfileProgress";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::BagfileProgress_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::cartographer_ros_msgs::BagfileProgress_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "#\n\
+# Licensed under the Apache License, Version 2.0 (the 'License');\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an 'AS IS' BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+\n\
+# Contains general information about the bagfiles processing progress\n\
+\n\
+string current_bagfile_name\n\
+uint32 current_bagfile_id\n\
+uint32 total_bagfiles\n\
+uint32 total_messages\n\
+uint32 processed_messages\n\
+float32 total_seconds\n\
+float32 processed_seconds\n\
+";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::BagfileProgress_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::cartographer_ros_msgs::BagfileProgress_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.current_bagfile_name);
+      stream.next(m.current_bagfile_id);
+      stream.next(m.total_bagfiles);
+      stream.next(m.total_messages);
+      stream.next(m.processed_messages);
+      stream.next(m.total_seconds);
+      stream.next(m.processed_seconds);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct BagfileProgress_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::cartographer_ros_msgs::BagfileProgress_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::cartographer_ros_msgs::BagfileProgress_<ContainerAllocator>& v)
+  {
+    s << indent << "current_bagfile_name: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + "  ", v.current_bagfile_name);
+    s << indent << "current_bagfile_id: ";
+    Printer<uint32_t>::stream(s, indent + "  ", v.current_bagfile_id);
+    s << indent << "total_bagfiles: ";
+    Printer<uint32_t>::stream(s, indent + "  ", v.total_bagfiles);
+    s << indent << "total_messages: ";
+    Printer<uint32_t>::stream(s, indent + "  ", v.total_messages);
+    s << indent << "processed_messages: ";
+    Printer<uint32_t>::stream(s, indent + "  ", v.processed_messages);
+    s << indent << "total_seconds: ";
+    Printer<float>::stream(s, indent + "  ", v.total_seconds);
+    s << indent << "processed_seconds: ";
+    Printer<float>::stream(s, indent + "  ", v.processed_seconds);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // CARTOGRAPHER_ROS_MSGS_MESSAGE_BAGFILEPROGRESS_H

devel/include/cartographer_ros_msgs/FinishTrajectory.h

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

devel/include/cartographer_ros_msgs/FinishTrajectoryRequest.h

@@ -0,0 +1,201 @@
+// Generated by gencpp from file cartographer_ros_msgs/FinishTrajectoryRequest.msg
+// DO NOT EDIT!
+
+
+#ifndef CARTOGRAPHER_ROS_MSGS_MESSAGE_FINISHTRAJECTORYREQUEST_H
+#define CARTOGRAPHER_ROS_MSGS_MESSAGE_FINISHTRAJECTORYREQUEST_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+
+namespace cartographer_ros_msgs
+{
+template <class ContainerAllocator>
+struct FinishTrajectoryRequest_
+{
+  typedef FinishTrajectoryRequest_<ContainerAllocator> Type;
+
+  FinishTrajectoryRequest_()
+    : trajectory_id(0)  {
+    }
+  FinishTrajectoryRequest_(const ContainerAllocator& _alloc)
+    : trajectory_id(0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef int32_t _trajectory_id_type;
+  _trajectory_id_type trajectory_id;
+
+
+
+
+
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::FinishTrajectoryRequest_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::FinishTrajectoryRequest_<ContainerAllocator> const> ConstPtr;
+
+}; // struct FinishTrajectoryRequest_
+
+typedef ::cartographer_ros_msgs::FinishTrajectoryRequest_<std::allocator<void> > FinishTrajectoryRequest;
+
+typedef boost::shared_ptr< ::cartographer_ros_msgs::FinishTrajectoryRequest > FinishTrajectoryRequestPtr;
+typedef boost::shared_ptr< ::cartographer_ros_msgs::FinishTrajectoryRequest const> FinishTrajectoryRequestConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::cartographer_ros_msgs::FinishTrajectoryRequest_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::cartographer_ros_msgs::FinishTrajectoryRequest_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace cartographer_ros_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'cartographer_ros_msgs': ['/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_ros_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::FinishTrajectoryRequest_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::FinishTrajectoryRequest_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::FinishTrajectoryRequest_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::FinishTrajectoryRequest_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::FinishTrajectoryRequest_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::FinishTrajectoryRequest_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::cartographer_ros_msgs::FinishTrajectoryRequest_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "6e190c4be941828bcd09ea05053f4bb5";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::FinishTrajectoryRequest_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x6e190c4be941828bULL;
+  static const uint64_t static_value2 = 0xcd09ea05053f4bb5ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::cartographer_ros_msgs::FinishTrajectoryRequest_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/FinishTrajectoryRequest";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::FinishTrajectoryRequest_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::cartographer_ros_msgs::FinishTrajectoryRequest_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+int32 trajectory_id\n\
+";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::FinishTrajectoryRequest_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::cartographer_ros_msgs::FinishTrajectoryRequest_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.trajectory_id);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct FinishTrajectoryRequest_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::cartographer_ros_msgs::FinishTrajectoryRequest_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::cartographer_ros_msgs::FinishTrajectoryRequest_<ContainerAllocator>& v)
+  {
+    s << indent << "trajectory_id: ";
+    Printer<int32_t>::stream(s, indent + "  ", v.trajectory_id);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // CARTOGRAPHER_ROS_MSGS_MESSAGE_FINISHTRAJECTORYREQUEST_H

devel/include/cartographer_ros_msgs/FinishTrajectoryResponse.h

@@ -0,0 +1,210 @@
+// Generated by gencpp from file cartographer_ros_msgs/FinishTrajectoryResponse.msg
+// DO NOT EDIT!
+
+
+#ifndef CARTOGRAPHER_ROS_MSGS_MESSAGE_FINISHTRAJECTORYRESPONSE_H
+#define CARTOGRAPHER_ROS_MSGS_MESSAGE_FINISHTRAJECTORYRESPONSE_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <cartographer_ros_msgs/StatusResponse.h>
+
+namespace cartographer_ros_msgs
+{
+template <class ContainerAllocator>
+struct FinishTrajectoryResponse_
+{
+  typedef FinishTrajectoryResponse_<ContainerAllocator> Type;
+
+  FinishTrajectoryResponse_()
+    : status()  {
+    }
+  FinishTrajectoryResponse_(const ContainerAllocator& _alloc)
+    : status(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator>  _status_type;
+  _status_type status;
+
+
+
+
+
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::FinishTrajectoryResponse_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::FinishTrajectoryResponse_<ContainerAllocator> const> ConstPtr;
+
+}; // struct FinishTrajectoryResponse_
+
+typedef ::cartographer_ros_msgs::FinishTrajectoryResponse_<std::allocator<void> > FinishTrajectoryResponse;
+
+typedef boost::shared_ptr< ::cartographer_ros_msgs::FinishTrajectoryResponse > FinishTrajectoryResponsePtr;
+typedef boost::shared_ptr< ::cartographer_ros_msgs::FinishTrajectoryResponse const> FinishTrajectoryResponseConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::cartographer_ros_msgs::FinishTrajectoryResponse_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::cartographer_ros_msgs::FinishTrajectoryResponse_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace cartographer_ros_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'cartographer_ros_msgs': ['/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_ros_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::FinishTrajectoryResponse_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::FinishTrajectoryResponse_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::FinishTrajectoryResponse_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::FinishTrajectoryResponse_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::FinishTrajectoryResponse_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::FinishTrajectoryResponse_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::cartographer_ros_msgs::FinishTrajectoryResponse_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "4e6ca4e44081fa06b258fa12804ea7cb";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::FinishTrajectoryResponse_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x4e6ca4e44081fa06ULL;
+  static const uint64_t static_value2 = 0xb258fa12804ea7cbULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::cartographer_ros_msgs::FinishTrajectoryResponse_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/FinishTrajectoryResponse";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::FinishTrajectoryResponse_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::cartographer_ros_msgs::FinishTrajectoryResponse_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/StatusResponse status\n\
+\n\
+\n\
+================================================================================\n\
+MSG: cartographer_ros_msgs/StatusResponse\n\
+# Copyright 2018 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+# A common message type to indicate the outcome of a service call.\n\
+uint8 code\n\
+string message\n\
+";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::FinishTrajectoryResponse_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::cartographer_ros_msgs::FinishTrajectoryResponse_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.status);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct FinishTrajectoryResponse_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::cartographer_ros_msgs::FinishTrajectoryResponse_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::cartographer_ros_msgs::FinishTrajectoryResponse_<ContainerAllocator>& v)
+  {
+    s << indent << "status: ";
+    s << std::endl;
+    Printer< ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator> >::stream(s, indent + "  ", v.status);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // CARTOGRAPHER_ROS_MSGS_MESSAGE_FINISHTRAJECTORYRESPONSE_H

devel/include/cartographer_ros_msgs/GetTrajectoryStates.h

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

devel/include/cartographer_ros_msgs/GetTrajectoryStatesRequest.h

@@ -0,0 +1,193 @@
+// Generated by gencpp from file cartographer_ros_msgs/GetTrajectoryStatesRequest.msg
+// DO NOT EDIT!
+
+
+#ifndef CARTOGRAPHER_ROS_MSGS_MESSAGE_GETTRAJECTORYSTATESREQUEST_H
+#define CARTOGRAPHER_ROS_MSGS_MESSAGE_GETTRAJECTORYSTATESREQUEST_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+
+namespace cartographer_ros_msgs
+{
+template <class ContainerAllocator>
+struct GetTrajectoryStatesRequest_
+{
+  typedef GetTrajectoryStatesRequest_<ContainerAllocator> Type;
+
+  GetTrajectoryStatesRequest_()
+    {
+    }
+  GetTrajectoryStatesRequest_(const ContainerAllocator& _alloc)
+    {
+  (void)_alloc;
+    }
+
+
+
+
+
+
+
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::GetTrajectoryStatesRequest_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::GetTrajectoryStatesRequest_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetTrajectoryStatesRequest_
+
+typedef ::cartographer_ros_msgs::GetTrajectoryStatesRequest_<std::allocator<void> > GetTrajectoryStatesRequest;
+
+typedef boost::shared_ptr< ::cartographer_ros_msgs::GetTrajectoryStatesRequest > GetTrajectoryStatesRequestPtr;
+typedef boost::shared_ptr< ::cartographer_ros_msgs::GetTrajectoryStatesRequest const> GetTrajectoryStatesRequestConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::cartographer_ros_msgs::GetTrajectoryStatesRequest_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::cartographer_ros_msgs::GetTrajectoryStatesRequest_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace cartographer_ros_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'cartographer_ros_msgs': ['/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_ros_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::GetTrajectoryStatesRequest_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::GetTrajectoryStatesRequest_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::GetTrajectoryStatesRequest_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::GetTrajectoryStatesRequest_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::GetTrajectoryStatesRequest_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::GetTrajectoryStatesRequest_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::cartographer_ros_msgs::GetTrajectoryStatesRequest_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "d41d8cd98f00b204e9800998ecf8427e";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::GetTrajectoryStatesRequest_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0xd41d8cd98f00b204ULL;
+  static const uint64_t static_value2 = 0xe9800998ecf8427eULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::cartographer_ros_msgs::GetTrajectoryStatesRequest_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/GetTrajectoryStatesRequest";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::GetTrajectoryStatesRequest_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::cartographer_ros_msgs::GetTrajectoryStatesRequest_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::GetTrajectoryStatesRequest_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::cartographer_ros_msgs::GetTrajectoryStatesRequest_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream&, T)
+    {}
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct GetTrajectoryStatesRequest_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::cartographer_ros_msgs::GetTrajectoryStatesRequest_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream&, const std::string&, const ::cartographer_ros_msgs::GetTrajectoryStatesRequest_<ContainerAllocator>&)
+  {}
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // CARTOGRAPHER_ROS_MSGS_MESSAGE_GETTRAJECTORYSTATESREQUEST_H

devel/include/cartographer_ros_msgs/GetTrajectoryStatesResponse.h

@@ -0,0 +1,264 @@
+// Generated by gencpp from file cartographer_ros_msgs/GetTrajectoryStatesResponse.msg
+// DO NOT EDIT!
+
+
+#ifndef CARTOGRAPHER_ROS_MSGS_MESSAGE_GETTRAJECTORYSTATESRESPONSE_H
+#define CARTOGRAPHER_ROS_MSGS_MESSAGE_GETTRAJECTORYSTATESRESPONSE_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <cartographer_ros_msgs/StatusResponse.h>
+#include <cartographer_ros_msgs/TrajectoryStates.h>
+
+namespace cartographer_ros_msgs
+{
+template <class ContainerAllocator>
+struct GetTrajectoryStatesResponse_
+{
+  typedef GetTrajectoryStatesResponse_<ContainerAllocator> Type;
+
+  GetTrajectoryStatesResponse_()
+    : status()
+    , trajectory_states()  {
+    }
+  GetTrajectoryStatesResponse_(const ContainerAllocator& _alloc)
+    : status(_alloc)
+    , trajectory_states(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator>  _status_type;
+  _status_type status;
+
+   typedef  ::cartographer_ros_msgs::TrajectoryStates_<ContainerAllocator>  _trajectory_states_type;
+  _trajectory_states_type trajectory_states;
+
+
+
+
+
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::GetTrajectoryStatesResponse_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::GetTrajectoryStatesResponse_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetTrajectoryStatesResponse_
+
+typedef ::cartographer_ros_msgs::GetTrajectoryStatesResponse_<std::allocator<void> > GetTrajectoryStatesResponse;
+
+typedef boost::shared_ptr< ::cartographer_ros_msgs::GetTrajectoryStatesResponse > GetTrajectoryStatesResponsePtr;
+typedef boost::shared_ptr< ::cartographer_ros_msgs::GetTrajectoryStatesResponse const> GetTrajectoryStatesResponseConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::cartographer_ros_msgs::GetTrajectoryStatesResponse_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::cartographer_ros_msgs::GetTrajectoryStatesResponse_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace cartographer_ros_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'cartographer_ros_msgs': ['/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_ros_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::GetTrajectoryStatesResponse_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::GetTrajectoryStatesResponse_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::GetTrajectoryStatesResponse_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::GetTrajectoryStatesResponse_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::GetTrajectoryStatesResponse_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::GetTrajectoryStatesResponse_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::cartographer_ros_msgs::GetTrajectoryStatesResponse_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "b9e3b373f17df088ee6dcd817b79dff0";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::GetTrajectoryStatesResponse_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0xb9e3b373f17df088ULL;
+  static const uint64_t static_value2 = 0xee6dcd817b79dff0ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::cartographer_ros_msgs::GetTrajectoryStatesResponse_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/GetTrajectoryStatesResponse";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::GetTrajectoryStatesResponse_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::cartographer_ros_msgs::GetTrajectoryStatesResponse_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/StatusResponse status\n\
+cartographer_ros_msgs/TrajectoryStates trajectory_states\n\
+\n\
+\n\
+================================================================================\n\
+MSG: cartographer_ros_msgs/StatusResponse\n\
+# Copyright 2018 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+# A common message type to indicate the outcome of a service call.\n\
+uint8 code\n\
+string message\n\
+\n\
+================================================================================\n\
+MSG: cartographer_ros_msgs/TrajectoryStates\n\
+# Copyright 2018 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the 'License');\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an 'AS IS' BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+uint8 ACTIVE = 0\n\
+uint8 FINISHED = 1\n\
+uint8 FROZEN = 2\n\
+uint8 DELETED = 3\n\
+\n\
+std_msgs/Header header\n\
+int32[] trajectory_id\n\
+uint8[] trajectory_state\n\
+\n\
+================================================================================\n\
+MSG: std_msgs/Header\n\
+# Standard metadata for higher-level stamped data types.\n\
+# This is generally used to communicate timestamped data \n\
+# in a particular coordinate frame.\n\
+# \n\
+# sequence ID: consecutively increasing ID \n\
+uint32 seq\n\
+#Two-integer timestamp that is expressed as:\n\
+# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\
+# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\
+# time-handling sugar is provided by the client library\n\
+time stamp\n\
+#Frame this data is associated with\n\
+# 0: no frame\n\
+# 1: global frame\n\
+string frame_id\n\
+";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::GetTrajectoryStatesResponse_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::cartographer_ros_msgs::GetTrajectoryStatesResponse_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.status);
+      stream.next(m.trajectory_states);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct GetTrajectoryStatesResponse_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::cartographer_ros_msgs::GetTrajectoryStatesResponse_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::cartographer_ros_msgs::GetTrajectoryStatesResponse_<ContainerAllocator>& v)
+  {
+    s << indent << "status: ";
+    s << std::endl;
+    Printer< ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator> >::stream(s, indent + "  ", v.status);
+    s << indent << "trajectory_states: ";
+    s << std::endl;
+    Printer< ::cartographer_ros_msgs::TrajectoryStates_<ContainerAllocator> >::stream(s, indent + "  ", v.trajectory_states);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // CARTOGRAPHER_ROS_MSGS_MESSAGE_GETTRAJECTORYSTATESRESPONSE_H

devel/include/cartographer_ros_msgs/HistogramBucket.h

@@ -0,0 +1,213 @@
+// Generated by gencpp from file cartographer_ros_msgs/HistogramBucket.msg
+// DO NOT EDIT!
+
+
+#ifndef CARTOGRAPHER_ROS_MSGS_MESSAGE_HISTOGRAMBUCKET_H
+#define CARTOGRAPHER_ROS_MSGS_MESSAGE_HISTOGRAMBUCKET_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+
+namespace cartographer_ros_msgs
+{
+template <class ContainerAllocator>
+struct HistogramBucket_
+{
+  typedef HistogramBucket_<ContainerAllocator> Type;
+
+  HistogramBucket_()
+    : bucket_boundary(0.0)
+    , count(0.0)  {
+    }
+  HistogramBucket_(const ContainerAllocator& _alloc)
+    : bucket_boundary(0.0)
+    , count(0.0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef double _bucket_boundary_type;
+  _bucket_boundary_type bucket_boundary;
+
+   typedef double _count_type;
+  _count_type count;
+
+
+
+
+
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::HistogramBucket_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::HistogramBucket_<ContainerAllocator> const> ConstPtr;
+
+}; // struct HistogramBucket_
+
+typedef ::cartographer_ros_msgs::HistogramBucket_<std::allocator<void> > HistogramBucket;
+
+typedef boost::shared_ptr< ::cartographer_ros_msgs::HistogramBucket > HistogramBucketPtr;
+typedef boost::shared_ptr< ::cartographer_ros_msgs::HistogramBucket const> HistogramBucketConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::cartographer_ros_msgs::HistogramBucket_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::cartographer_ros_msgs::HistogramBucket_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace cartographer_ros_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'cartographer_ros_msgs': ['/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_ros_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::HistogramBucket_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::HistogramBucket_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::HistogramBucket_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::HistogramBucket_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::HistogramBucket_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::HistogramBucket_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::cartographer_ros_msgs::HistogramBucket_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "b579df35b32758cf09f65ae223aea0ad";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::HistogramBucket_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0xb579df35b32758cfULL;
+  static const uint64_t static_value2 = 0x09f65ae223aea0adULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::cartographer_ros_msgs::HistogramBucket_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/HistogramBucket";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::HistogramBucket_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::cartographer_ros_msgs::HistogramBucket_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# 2018 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+# A histogram bucket counts values x for which:\n\
+#   previous_boundary < x <= bucket_boundary\n\
+# holds.\n\
+float64 bucket_boundary\n\
+float64 count\n\
+";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::HistogramBucket_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::cartographer_ros_msgs::HistogramBucket_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.bucket_boundary);
+      stream.next(m.count);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct HistogramBucket_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::cartographer_ros_msgs::HistogramBucket_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::cartographer_ros_msgs::HistogramBucket_<ContainerAllocator>& v)
+  {
+    s << indent << "bucket_boundary: ";
+    Printer<double>::stream(s, indent + "  ", v.bucket_boundary);
+    s << indent << "count: ";
+    Printer<double>::stream(s, indent + "  ", v.count);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // CARTOGRAPHER_ROS_MSGS_MESSAGE_HISTOGRAMBUCKET_H

devel/include/cartographer_ros_msgs/LandmarkEntry.h

@@ -0,0 +1,252 @@
+// Generated by gencpp from file cartographer_ros_msgs/LandmarkEntry.msg
+// DO NOT EDIT!
+
+
+#ifndef CARTOGRAPHER_ROS_MSGS_MESSAGE_LANDMARKENTRY_H
+#define CARTOGRAPHER_ROS_MSGS_MESSAGE_LANDMARKENTRY_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <geometry_msgs/Pose.h>
+
+namespace cartographer_ros_msgs
+{
+template <class ContainerAllocator>
+struct LandmarkEntry_
+{
+  typedef LandmarkEntry_<ContainerAllocator> Type;
+
+  LandmarkEntry_()
+    : id()
+    , tracking_from_landmark_transform()
+    , translation_weight(0.0)
+    , rotation_weight(0.0)  {
+    }
+  LandmarkEntry_(const ContainerAllocator& _alloc)
+    : id(_alloc)
+    , tracking_from_landmark_transform(_alloc)
+    , translation_weight(0.0)
+    , rotation_weight(0.0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _id_type;
+  _id_type id;
+
+   typedef  ::geometry_msgs::Pose_<ContainerAllocator>  _tracking_from_landmark_transform_type;
+  _tracking_from_landmark_transform_type tracking_from_landmark_transform;
+
+   typedef double _translation_weight_type;
+  _translation_weight_type translation_weight;
+
+   typedef double _rotation_weight_type;
+  _rotation_weight_type rotation_weight;
+
+
+
+
+
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::LandmarkEntry_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::LandmarkEntry_<ContainerAllocator> const> ConstPtr;
+
+}; // struct LandmarkEntry_
+
+typedef ::cartographer_ros_msgs::LandmarkEntry_<std::allocator<void> > LandmarkEntry;
+
+typedef boost::shared_ptr< ::cartographer_ros_msgs::LandmarkEntry > LandmarkEntryPtr;
+typedef boost::shared_ptr< ::cartographer_ros_msgs::LandmarkEntry const> LandmarkEntryConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::cartographer_ros_msgs::LandmarkEntry_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::cartographer_ros_msgs::LandmarkEntry_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace cartographer_ros_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'cartographer_ros_msgs': ['/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_ros_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::LandmarkEntry_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::LandmarkEntry_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::LandmarkEntry_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::LandmarkEntry_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::LandmarkEntry_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::LandmarkEntry_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::cartographer_ros_msgs::LandmarkEntry_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "133f8dd7259f83a87eb4d78b301c0b70";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::LandmarkEntry_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x133f8dd7259f83a8ULL;
+  static const uint64_t static_value2 = 0x7eb4d78b301c0b70ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::cartographer_ros_msgs::LandmarkEntry_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/LandmarkEntry";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::LandmarkEntry_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::cartographer_ros_msgs::LandmarkEntry_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# 2018 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+string id\n\
+geometry_msgs/Pose tracking_from_landmark_transform\n\
+float64 translation_weight\n\
+float64 rotation_weight\n\
+\n\
+================================================================================\n\
+MSG: geometry_msgs/Pose\n\
+# A representation of pose in free space, composed of position and orientation. \n\
+Point position\n\
+Quaternion orientation\n\
+\n\
+================================================================================\n\
+MSG: geometry_msgs/Point\n\
+# This contains the position of a point in free space\n\
+float64 x\n\
+float64 y\n\
+float64 z\n\
+\n\
+================================================================================\n\
+MSG: geometry_msgs/Quaternion\n\
+# This represents an orientation in free space in quaternion form.\n\
+\n\
+float64 x\n\
+float64 y\n\
+float64 z\n\
+float64 w\n\
+";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::LandmarkEntry_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::cartographer_ros_msgs::LandmarkEntry_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.id);
+      stream.next(m.tracking_from_landmark_transform);
+      stream.next(m.translation_weight);
+      stream.next(m.rotation_weight);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct LandmarkEntry_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::cartographer_ros_msgs::LandmarkEntry_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::cartographer_ros_msgs::LandmarkEntry_<ContainerAllocator>& v)
+  {
+    s << indent << "id: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + "  ", v.id);
+    s << indent << "tracking_from_landmark_transform: ";
+    s << std::endl;
+    Printer< ::geometry_msgs::Pose_<ContainerAllocator> >::stream(s, indent + "  ", v.tracking_from_landmark_transform);
+    s << indent << "translation_weight: ";
+    Printer<double>::stream(s, indent + "  ", v.translation_weight);
+    s << indent << "rotation_weight: ";
+    Printer<double>::stream(s, indent + "  ", v.rotation_weight);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // CARTOGRAPHER_ROS_MSGS_MESSAGE_LANDMARKENTRY_H

devel/include/cartographer_ros_msgs/LandmarkList.h

@@ -0,0 +1,280 @@
+// Generated by gencpp from file cartographer_ros_msgs/LandmarkList.msg
+// DO NOT EDIT!
+
+
+#ifndef CARTOGRAPHER_ROS_MSGS_MESSAGE_LANDMARKLIST_H
+#define CARTOGRAPHER_ROS_MSGS_MESSAGE_LANDMARKLIST_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <std_msgs/Header.h>
+#include <cartographer_ros_msgs/LandmarkEntry.h>
+
+namespace cartographer_ros_msgs
+{
+template <class ContainerAllocator>
+struct LandmarkList_
+{
+  typedef LandmarkList_<ContainerAllocator> Type;
+
+  LandmarkList_()
+    : header()
+    , landmarks()  {
+    }
+  LandmarkList_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , landmarks(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
+  _header_type header;
+
+   typedef std::vector< ::cartographer_ros_msgs::LandmarkEntry_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::cartographer_ros_msgs::LandmarkEntry_<ContainerAllocator> >::other >  _landmarks_type;
+  _landmarks_type landmarks;
+
+
+
+
+
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::LandmarkList_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::LandmarkList_<ContainerAllocator> const> ConstPtr;
+
+}; // struct LandmarkList_
+
+typedef ::cartographer_ros_msgs::LandmarkList_<std::allocator<void> > LandmarkList;
+
+typedef boost::shared_ptr< ::cartographer_ros_msgs::LandmarkList > LandmarkListPtr;
+typedef boost::shared_ptr< ::cartographer_ros_msgs::LandmarkList const> LandmarkListConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::cartographer_ros_msgs::LandmarkList_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::cartographer_ros_msgs::LandmarkList_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace cartographer_ros_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True}
+// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'cartographer_ros_msgs': ['/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_ros_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::LandmarkList_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::LandmarkList_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::LandmarkList_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::LandmarkList_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::LandmarkList_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::LandmarkList_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::cartographer_ros_msgs::LandmarkList_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "322e3fb6b49d8fcd97544b4896b0ae66";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::LandmarkList_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x322e3fb6b49d8fcdULL;
+  static const uint64_t static_value2 = 0x97544b4896b0ae66ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::cartographer_ros_msgs::LandmarkList_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/LandmarkList";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::LandmarkList_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::cartographer_ros_msgs::LandmarkList_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# Copyright 2018 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+std_msgs/Header header\n\
+cartographer_ros_msgs/LandmarkEntry[] landmarks\n\
+\n\
+================================================================================\n\
+MSG: std_msgs/Header\n\
+# Standard metadata for higher-level stamped data types.\n\
+# This is generally used to communicate timestamped data \n\
+# in a particular coordinate frame.\n\
+# \n\
+# sequence ID: consecutively increasing ID \n\
+uint32 seq\n\
+#Two-integer timestamp that is expressed as:\n\
+# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\
+# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\
+# time-handling sugar is provided by the client library\n\
+time stamp\n\
+#Frame this data is associated with\n\
+# 0: no frame\n\
+# 1: global frame\n\
+string frame_id\n\
+\n\
+================================================================================\n\
+MSG: cartographer_ros_msgs/LandmarkEntry\n\
+# 2018 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+string id\n\
+geometry_msgs/Pose tracking_from_landmark_transform\n\
+float64 translation_weight\n\
+float64 rotation_weight\n\
+\n\
+================================================================================\n\
+MSG: geometry_msgs/Pose\n\
+# A representation of pose in free space, composed of position and orientation. \n\
+Point position\n\
+Quaternion orientation\n\
+\n\
+================================================================================\n\
+MSG: geometry_msgs/Point\n\
+# This contains the position of a point in free space\n\
+float64 x\n\
+float64 y\n\
+float64 z\n\
+\n\
+================================================================================\n\
+MSG: geometry_msgs/Quaternion\n\
+# This represents an orientation in free space in quaternion form.\n\
+\n\
+float64 x\n\
+float64 y\n\
+float64 z\n\
+float64 w\n\
+";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::LandmarkList_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::cartographer_ros_msgs::LandmarkList_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.header);
+      stream.next(m.landmarks);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct LandmarkList_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::cartographer_ros_msgs::LandmarkList_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::cartographer_ros_msgs::LandmarkList_<ContainerAllocator>& v)
+  {
+    s << indent << "header: ";
+    s << std::endl;
+    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
+    s << indent << "landmarks[]" << std::endl;
+    for (size_t i = 0; i < v.landmarks.size(); ++i)
+    {
+      s << indent << "  landmarks[" << i << "]: ";
+      s << std::endl;
+      s << indent;
+      Printer< ::cartographer_ros_msgs::LandmarkEntry_<ContainerAllocator> >::stream(s, indent + "    ", v.landmarks[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // CARTOGRAPHER_ROS_MSGS_MESSAGE_LANDMARKLIST_H

devel/include/cartographer_ros_msgs/Metric.h

@@ -0,0 +1,302 @@
+// Generated by gencpp from file cartographer_ros_msgs/Metric.msg
+// DO NOT EDIT!
+
+
+#ifndef CARTOGRAPHER_ROS_MSGS_MESSAGE_METRIC_H
+#define CARTOGRAPHER_ROS_MSGS_MESSAGE_METRIC_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <cartographer_ros_msgs/MetricLabel.h>
+#include <cartographer_ros_msgs/HistogramBucket.h>
+
+namespace cartographer_ros_msgs
+{
+template <class ContainerAllocator>
+struct Metric_
+{
+  typedef Metric_<ContainerAllocator> Type;
+
+  Metric_()
+    : type(0)
+    , labels()
+    , value(0.0)
+    , counts_by_bucket()  {
+    }
+  Metric_(const ContainerAllocator& _alloc)
+    : type(0)
+    , labels(_alloc)
+    , value(0.0)
+    , counts_by_bucket(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef uint8_t _type_type;
+  _type_type type;
+
+   typedef std::vector< ::cartographer_ros_msgs::MetricLabel_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::cartographer_ros_msgs::MetricLabel_<ContainerAllocator> >::other >  _labels_type;
+  _labels_type labels;
+
+   typedef double _value_type;
+  _value_type value;
+
+   typedef std::vector< ::cartographer_ros_msgs::HistogramBucket_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::cartographer_ros_msgs::HistogramBucket_<ContainerAllocator> >::other >  _counts_by_bucket_type;
+  _counts_by_bucket_type counts_by_bucket;
+
+
+
+  enum {
+    TYPE_COUNTER = 0u,
+    TYPE_GAUGE = 1u,
+    TYPE_HISTOGRAM = 2u,
+  };
+
+
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::Metric_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::Metric_<ContainerAllocator> const> ConstPtr;
+
+}; // struct Metric_
+
+typedef ::cartographer_ros_msgs::Metric_<std::allocator<void> > Metric;
+
+typedef boost::shared_ptr< ::cartographer_ros_msgs::Metric > MetricPtr;
+typedef boost::shared_ptr< ::cartographer_ros_msgs::Metric const> MetricConstPtr;
+
+// constants requiring out of line definition
+
+   
+
+   
+
+   
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::cartographer_ros_msgs::Metric_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::cartographer_ros_msgs::Metric_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace cartographer_ros_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'cartographer_ros_msgs': ['/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_ros_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::Metric_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::Metric_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::Metric_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::Metric_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::Metric_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::Metric_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::cartographer_ros_msgs::Metric_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "94a6ea1c6ef245b483a220f6769c8e36";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::Metric_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x94a6ea1c6ef245b4ULL;
+  static const uint64_t static_value2 = 0x83a220f6769c8e36ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::cartographer_ros_msgs::Metric_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/Metric";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::Metric_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::cartographer_ros_msgs::Metric_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# 2018 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+uint8 TYPE_COUNTER=0\n\
+uint8 TYPE_GAUGE=1\n\
+uint8 TYPE_HISTOGRAM=2\n\
+\n\
+uint8 type\n\
+cartographer_ros_msgs/MetricLabel[] labels\n\
+\n\
+# TYPE_COUNTER or TYPE_GAUGE\n\
+float64 value\n\
+\n\
+# TYPE_HISTOGRAM\n\
+cartographer_ros_msgs/HistogramBucket[] counts_by_bucket\n\
+\n\
+================================================================================\n\
+MSG: cartographer_ros_msgs/MetricLabel\n\
+# 2018 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+string key\n\
+string value\n\
+\n\
+================================================================================\n\
+MSG: cartographer_ros_msgs/HistogramBucket\n\
+# 2018 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+# A histogram bucket counts values x for which:\n\
+#   previous_boundary < x <= bucket_boundary\n\
+# holds.\n\
+float64 bucket_boundary\n\
+float64 count\n\
+";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::Metric_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::cartographer_ros_msgs::Metric_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.type);
+      stream.next(m.labels);
+      stream.next(m.value);
+      stream.next(m.counts_by_bucket);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct Metric_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::cartographer_ros_msgs::Metric_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::cartographer_ros_msgs::Metric_<ContainerAllocator>& v)
+  {
+    s << indent << "type: ";
+    Printer<uint8_t>::stream(s, indent + "  ", v.type);
+    s << indent << "labels[]" << std::endl;
+    for (size_t i = 0; i < v.labels.size(); ++i)
+    {
+      s << indent << "  labels[" << i << "]: ";
+      s << std::endl;
+      s << indent;
+      Printer< ::cartographer_ros_msgs::MetricLabel_<ContainerAllocator> >::stream(s, indent + "    ", v.labels[i]);
+    }
+    s << indent << "value: ";
+    Printer<double>::stream(s, indent + "  ", v.value);
+    s << indent << "counts_by_bucket[]" << std::endl;
+    for (size_t i = 0; i < v.counts_by_bucket.size(); ++i)
+    {
+      s << indent << "  counts_by_bucket[" << i << "]: ";
+      s << std::endl;
+      s << indent;
+      Printer< ::cartographer_ros_msgs::HistogramBucket_<ContainerAllocator> >::stream(s, indent + "    ", v.counts_by_bucket[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // CARTOGRAPHER_ROS_MSGS_MESSAGE_METRIC_H

devel/include/cartographer_ros_msgs/MetricFamily.h

@@ -0,0 +1,296 @@
+// Generated by gencpp from file cartographer_ros_msgs/MetricFamily.msg
+// DO NOT EDIT!
+
+
+#ifndef CARTOGRAPHER_ROS_MSGS_MESSAGE_METRICFAMILY_H
+#define CARTOGRAPHER_ROS_MSGS_MESSAGE_METRICFAMILY_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <cartographer_ros_msgs/Metric.h>
+
+namespace cartographer_ros_msgs
+{
+template <class ContainerAllocator>
+struct MetricFamily_
+{
+  typedef MetricFamily_<ContainerAllocator> Type;
+
+  MetricFamily_()
+    : name()
+    , description()
+    , metrics()  {
+    }
+  MetricFamily_(const ContainerAllocator& _alloc)
+    : name(_alloc)
+    , description(_alloc)
+    , metrics(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _name_type;
+  _name_type name;
+
+   typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _description_type;
+  _description_type description;
+
+   typedef std::vector< ::cartographer_ros_msgs::Metric_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::cartographer_ros_msgs::Metric_<ContainerAllocator> >::other >  _metrics_type;
+  _metrics_type metrics;
+
+
+
+
+
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::MetricFamily_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::MetricFamily_<ContainerAllocator> const> ConstPtr;
+
+}; // struct MetricFamily_
+
+typedef ::cartographer_ros_msgs::MetricFamily_<std::allocator<void> > MetricFamily;
+
+typedef boost::shared_ptr< ::cartographer_ros_msgs::MetricFamily > MetricFamilyPtr;
+typedef boost::shared_ptr< ::cartographer_ros_msgs::MetricFamily const> MetricFamilyConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::cartographer_ros_msgs::MetricFamily_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::cartographer_ros_msgs::MetricFamily_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace cartographer_ros_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'cartographer_ros_msgs': ['/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_ros_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::MetricFamily_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::MetricFamily_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::MetricFamily_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::MetricFamily_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::MetricFamily_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::MetricFamily_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::cartographer_ros_msgs::MetricFamily_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "583a11b161bb4a70f5df274715bcaf10";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::MetricFamily_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x583a11b161bb4a70ULL;
+  static const uint64_t static_value2 = 0xf5df274715bcaf10ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::cartographer_ros_msgs::MetricFamily_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/MetricFamily";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::MetricFamily_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::cartographer_ros_msgs::MetricFamily_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# 2018 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+string name\n\
+string description\n\
+cartographer_ros_msgs/Metric[] metrics\n\
+\n\
+================================================================================\n\
+MSG: cartographer_ros_msgs/Metric\n\
+# 2018 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+uint8 TYPE_COUNTER=0\n\
+uint8 TYPE_GAUGE=1\n\
+uint8 TYPE_HISTOGRAM=2\n\
+\n\
+uint8 type\n\
+cartographer_ros_msgs/MetricLabel[] labels\n\
+\n\
+# TYPE_COUNTER or TYPE_GAUGE\n\
+float64 value\n\
+\n\
+# TYPE_HISTOGRAM\n\
+cartographer_ros_msgs/HistogramBucket[] counts_by_bucket\n\
+\n\
+================================================================================\n\
+MSG: cartographer_ros_msgs/MetricLabel\n\
+# 2018 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+string key\n\
+string value\n\
+\n\
+================================================================================\n\
+MSG: cartographer_ros_msgs/HistogramBucket\n\
+# 2018 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+# A histogram bucket counts values x for which:\n\
+#   previous_boundary < x <= bucket_boundary\n\
+# holds.\n\
+float64 bucket_boundary\n\
+float64 count\n\
+";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::MetricFamily_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::cartographer_ros_msgs::MetricFamily_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.name);
+      stream.next(m.description);
+      stream.next(m.metrics);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct MetricFamily_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::cartographer_ros_msgs::MetricFamily_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::cartographer_ros_msgs::MetricFamily_<ContainerAllocator>& v)
+  {
+    s << indent << "name: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + "  ", v.name);
+    s << indent << "description: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + "  ", v.description);
+    s << indent << "metrics[]" << std::endl;
+    for (size_t i = 0; i < v.metrics.size(); ++i)
+    {
+      s << indent << "  metrics[" << i << "]: ";
+      s << std::endl;
+      s << indent;
+      Printer< ::cartographer_ros_msgs::Metric_<ContainerAllocator> >::stream(s, indent + "    ", v.metrics[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // CARTOGRAPHER_ROS_MSGS_MESSAGE_METRICFAMILY_H

devel/include/cartographer_ros_msgs/MetricLabel.h

@@ -0,0 +1,210 @@
+// Generated by gencpp from file cartographer_ros_msgs/MetricLabel.msg
+// DO NOT EDIT!
+
+
+#ifndef CARTOGRAPHER_ROS_MSGS_MESSAGE_METRICLABEL_H
+#define CARTOGRAPHER_ROS_MSGS_MESSAGE_METRICLABEL_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+
+namespace cartographer_ros_msgs
+{
+template <class ContainerAllocator>
+struct MetricLabel_
+{
+  typedef MetricLabel_<ContainerAllocator> Type;
+
+  MetricLabel_()
+    : key()
+    , value()  {
+    }
+  MetricLabel_(const ContainerAllocator& _alloc)
+    : key(_alloc)
+    , value(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _key_type;
+  _key_type key;
+
+   typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _value_type;
+  _value_type value;
+
+
+
+
+
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::MetricLabel_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::MetricLabel_<ContainerAllocator> const> ConstPtr;
+
+}; // struct MetricLabel_
+
+typedef ::cartographer_ros_msgs::MetricLabel_<std::allocator<void> > MetricLabel;
+
+typedef boost::shared_ptr< ::cartographer_ros_msgs::MetricLabel > MetricLabelPtr;
+typedef boost::shared_ptr< ::cartographer_ros_msgs::MetricLabel const> MetricLabelConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::cartographer_ros_msgs::MetricLabel_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::cartographer_ros_msgs::MetricLabel_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace cartographer_ros_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'cartographer_ros_msgs': ['/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_ros_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::MetricLabel_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::MetricLabel_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::MetricLabel_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::MetricLabel_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::MetricLabel_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::MetricLabel_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::cartographer_ros_msgs::MetricLabel_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cf57fdc6617a881a88c16e768132149c";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::MetricLabel_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0xcf57fdc6617a881aULL;
+  static const uint64_t static_value2 = 0x88c16e768132149cULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::cartographer_ros_msgs::MetricLabel_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/MetricLabel";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::MetricLabel_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::cartographer_ros_msgs::MetricLabel_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# 2018 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+string key\n\
+string value\n\
+";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::MetricLabel_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::cartographer_ros_msgs::MetricLabel_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.key);
+      stream.next(m.value);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct MetricLabel_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::cartographer_ros_msgs::MetricLabel_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::cartographer_ros_msgs::MetricLabel_<ContainerAllocator>& v)
+  {
+    s << indent << "key: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + "  ", v.key);
+    s << indent << "value: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + "  ", v.value);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // CARTOGRAPHER_ROS_MSGS_MESSAGE_METRICLABEL_H

devel/include/cartographer_ros_msgs/ReadMetrics.h

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

devel/include/cartographer_ros_msgs/ReadMetricsRequest.h

@@ -0,0 +1,192 @@
+// Generated by gencpp from file cartographer_ros_msgs/ReadMetricsRequest.msg
+// DO NOT EDIT!
+
+
+#ifndef CARTOGRAPHER_ROS_MSGS_MESSAGE_READMETRICSREQUEST_H
+#define CARTOGRAPHER_ROS_MSGS_MESSAGE_READMETRICSREQUEST_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+
+namespace cartographer_ros_msgs
+{
+template <class ContainerAllocator>
+struct ReadMetricsRequest_
+{
+  typedef ReadMetricsRequest_<ContainerAllocator> Type;
+
+  ReadMetricsRequest_()
+    {
+    }
+  ReadMetricsRequest_(const ContainerAllocator& _alloc)
+    {
+  (void)_alloc;
+    }
+
+
+
+
+
+
+
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::ReadMetricsRequest_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::ReadMetricsRequest_<ContainerAllocator> const> ConstPtr;
+
+}; // struct ReadMetricsRequest_
+
+typedef ::cartographer_ros_msgs::ReadMetricsRequest_<std::allocator<void> > ReadMetricsRequest;
+
+typedef boost::shared_ptr< ::cartographer_ros_msgs::ReadMetricsRequest > ReadMetricsRequestPtr;
+typedef boost::shared_ptr< ::cartographer_ros_msgs::ReadMetricsRequest const> ReadMetricsRequestConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::cartographer_ros_msgs::ReadMetricsRequest_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::cartographer_ros_msgs::ReadMetricsRequest_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace cartographer_ros_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'cartographer_ros_msgs': ['/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_ros_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::ReadMetricsRequest_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::ReadMetricsRequest_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::ReadMetricsRequest_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::ReadMetricsRequest_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::ReadMetricsRequest_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::ReadMetricsRequest_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::cartographer_ros_msgs::ReadMetricsRequest_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "d41d8cd98f00b204e9800998ecf8427e";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::ReadMetricsRequest_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0xd41d8cd98f00b204ULL;
+  static const uint64_t static_value2 = 0xe9800998ecf8427eULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::cartographer_ros_msgs::ReadMetricsRequest_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/ReadMetricsRequest";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::ReadMetricsRequest_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::cartographer_ros_msgs::ReadMetricsRequest_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::ReadMetricsRequest_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::cartographer_ros_msgs::ReadMetricsRequest_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream&, T)
+    {}
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct ReadMetricsRequest_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::cartographer_ros_msgs::ReadMetricsRequest_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream&, const std::string&, const ::cartographer_ros_msgs::ReadMetricsRequest_<ContainerAllocator>&)
+  {}
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // CARTOGRAPHER_ROS_MSGS_MESSAGE_READMETRICSREQUEST_H

devel/include/cartographer_ros_msgs/ReadMetricsResponse.h

@@ -0,0 +1,325 @@
+// Generated by gencpp from file cartographer_ros_msgs/ReadMetricsResponse.msg
+// DO NOT EDIT!
+
+
+#ifndef CARTOGRAPHER_ROS_MSGS_MESSAGE_READMETRICSRESPONSE_H
+#define CARTOGRAPHER_ROS_MSGS_MESSAGE_READMETRICSRESPONSE_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <cartographer_ros_msgs/StatusResponse.h>
+#include <cartographer_ros_msgs/MetricFamily.h>
+
+namespace cartographer_ros_msgs
+{
+template <class ContainerAllocator>
+struct ReadMetricsResponse_
+{
+  typedef ReadMetricsResponse_<ContainerAllocator> Type;
+
+  ReadMetricsResponse_()
+    : status()
+    , metric_families()
+    , timestamp()  {
+    }
+  ReadMetricsResponse_(const ContainerAllocator& _alloc)
+    : status(_alloc)
+    , metric_families(_alloc)
+    , timestamp()  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator>  _status_type;
+  _status_type status;
+
+   typedef std::vector< ::cartographer_ros_msgs::MetricFamily_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::cartographer_ros_msgs::MetricFamily_<ContainerAllocator> >::other >  _metric_families_type;
+  _metric_families_type metric_families;
+
+   typedef ros::Time _timestamp_type;
+  _timestamp_type timestamp;
+
+
+
+
+
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::ReadMetricsResponse_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::ReadMetricsResponse_<ContainerAllocator> const> ConstPtr;
+
+}; // struct ReadMetricsResponse_
+
+typedef ::cartographer_ros_msgs::ReadMetricsResponse_<std::allocator<void> > ReadMetricsResponse;
+
+typedef boost::shared_ptr< ::cartographer_ros_msgs::ReadMetricsResponse > ReadMetricsResponsePtr;
+typedef boost::shared_ptr< ::cartographer_ros_msgs::ReadMetricsResponse const> ReadMetricsResponseConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::cartographer_ros_msgs::ReadMetricsResponse_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::cartographer_ros_msgs::ReadMetricsResponse_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace cartographer_ros_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'cartographer_ros_msgs': ['/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_ros_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::ReadMetricsResponse_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::ReadMetricsResponse_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::ReadMetricsResponse_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::ReadMetricsResponse_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::ReadMetricsResponse_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::ReadMetricsResponse_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::cartographer_ros_msgs::ReadMetricsResponse_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "a1fe8d7dcf3708e96e015774b1df470e";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::ReadMetricsResponse_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0xa1fe8d7dcf3708e9ULL;
+  static const uint64_t static_value2 = 0x6e015774b1df470eULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::cartographer_ros_msgs::ReadMetricsResponse_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/ReadMetricsResponse";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::ReadMetricsResponse_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::cartographer_ros_msgs::ReadMetricsResponse_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/StatusResponse status\n\
+cartographer_ros_msgs/MetricFamily[] metric_families\n\
+time timestamp\n\
+\n\
+\n\
+================================================================================\n\
+MSG: cartographer_ros_msgs/StatusResponse\n\
+# Copyright 2018 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+# A common message type to indicate the outcome of a service call.\n\
+uint8 code\n\
+string message\n\
+\n\
+================================================================================\n\
+MSG: cartographer_ros_msgs/MetricFamily\n\
+# 2018 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+string name\n\
+string description\n\
+cartographer_ros_msgs/Metric[] metrics\n\
+\n\
+================================================================================\n\
+MSG: cartographer_ros_msgs/Metric\n\
+# 2018 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+uint8 TYPE_COUNTER=0\n\
+uint8 TYPE_GAUGE=1\n\
+uint8 TYPE_HISTOGRAM=2\n\
+\n\
+uint8 type\n\
+cartographer_ros_msgs/MetricLabel[] labels\n\
+\n\
+# TYPE_COUNTER or TYPE_GAUGE\n\
+float64 value\n\
+\n\
+# TYPE_HISTOGRAM\n\
+cartographer_ros_msgs/HistogramBucket[] counts_by_bucket\n\
+\n\
+================================================================================\n\
+MSG: cartographer_ros_msgs/MetricLabel\n\
+# 2018 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+string key\n\
+string value\n\
+\n\
+================================================================================\n\
+MSG: cartographer_ros_msgs/HistogramBucket\n\
+# 2018 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+# A histogram bucket counts values x for which:\n\
+#   previous_boundary < x <= bucket_boundary\n\
+# holds.\n\
+float64 bucket_boundary\n\
+float64 count\n\
+";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::ReadMetricsResponse_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::cartographer_ros_msgs::ReadMetricsResponse_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.status);
+      stream.next(m.metric_families);
+      stream.next(m.timestamp);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct ReadMetricsResponse_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::cartographer_ros_msgs::ReadMetricsResponse_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::cartographer_ros_msgs::ReadMetricsResponse_<ContainerAllocator>& v)
+  {
+    s << indent << "status: ";
+    s << std::endl;
+    Printer< ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator> >::stream(s, indent + "  ", v.status);
+    s << indent << "metric_families[]" << std::endl;
+    for (size_t i = 0; i < v.metric_families.size(); ++i)
+    {
+      s << indent << "  metric_families[" << i << "]: ";
+      s << std::endl;
+      s << indent;
+      Printer< ::cartographer_ros_msgs::MetricFamily_<ContainerAllocator> >::stream(s, indent + "    ", v.metric_families[i]);
+    }
+    s << indent << "timestamp: ";
+    Printer<ros::Time>::stream(s, indent + "  ", v.timestamp);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // CARTOGRAPHER_ROS_MSGS_MESSAGE_READMETRICSRESPONSE_H

devel/include/cartographer_ros_msgs/SensorTopics.h

@@ -0,0 +1,255 @@
+// Generated by gencpp from file cartographer_ros_msgs/SensorTopics.msg
+// DO NOT EDIT!
+
+
+#ifndef CARTOGRAPHER_ROS_MSGS_MESSAGE_SENSORTOPICS_H
+#define CARTOGRAPHER_ROS_MSGS_MESSAGE_SENSORTOPICS_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+
+namespace cartographer_ros_msgs
+{
+template <class ContainerAllocator>
+struct SensorTopics_
+{
+  typedef SensorTopics_<ContainerAllocator> Type;
+
+  SensorTopics_()
+    : laser_scan_topic()
+    , multi_echo_laser_scan_topic()
+    , point_cloud2_topic()
+    , imu_topic()
+    , odometry_topic()
+    , nav_sat_fix_topic()
+    , landmark_topic()  {
+    }
+  SensorTopics_(const ContainerAllocator& _alloc)
+    : laser_scan_topic(_alloc)
+    , multi_echo_laser_scan_topic(_alloc)
+    , point_cloud2_topic(_alloc)
+    , imu_topic(_alloc)
+    , odometry_topic(_alloc)
+    , nav_sat_fix_topic(_alloc)
+    , landmark_topic(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _laser_scan_topic_type;
+  _laser_scan_topic_type laser_scan_topic;
+
+   typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _multi_echo_laser_scan_topic_type;
+  _multi_echo_laser_scan_topic_type multi_echo_laser_scan_topic;
+
+   typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _point_cloud2_topic_type;
+  _point_cloud2_topic_type point_cloud2_topic;
+
+   typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _imu_topic_type;
+  _imu_topic_type imu_topic;
+
+   typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _odometry_topic_type;
+  _odometry_topic_type odometry_topic;
+
+   typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _nav_sat_fix_topic_type;
+  _nav_sat_fix_topic_type nav_sat_fix_topic;
+
+   typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _landmark_topic_type;
+  _landmark_topic_type landmark_topic;
+
+
+
+
+
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::SensorTopics_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::SensorTopics_<ContainerAllocator> const> ConstPtr;
+
+}; // struct SensorTopics_
+
+typedef ::cartographer_ros_msgs::SensorTopics_<std::allocator<void> > SensorTopics;
+
+typedef boost::shared_ptr< ::cartographer_ros_msgs::SensorTopics > SensorTopicsPtr;
+typedef boost::shared_ptr< ::cartographer_ros_msgs::SensorTopics const> SensorTopicsConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::cartographer_ros_msgs::SensorTopics_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::cartographer_ros_msgs::SensorTopics_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace cartographer_ros_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'cartographer_ros_msgs': ['/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_ros_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::SensorTopics_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::SensorTopics_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::SensorTopics_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::SensorTopics_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::SensorTopics_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::SensorTopics_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::cartographer_ros_msgs::SensorTopics_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "bafbff7d66e3eeeb8d4a9195096cba08";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::SensorTopics_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0xbafbff7d66e3eeebULL;
+  static const uint64_t static_value2 = 0x8d4a9195096cba08ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::cartographer_ros_msgs::SensorTopics_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/SensorTopics";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::SensorTopics_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::cartographer_ros_msgs::SensorTopics_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# Copyright 2016 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+string laser_scan_topic\n\
+string multi_echo_laser_scan_topic\n\
+string point_cloud2_topic\n\
+string imu_topic\n\
+string odometry_topic\n\
+string nav_sat_fix_topic\n\
+string landmark_topic\n\
+";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::SensorTopics_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::cartographer_ros_msgs::SensorTopics_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.laser_scan_topic);
+      stream.next(m.multi_echo_laser_scan_topic);
+      stream.next(m.point_cloud2_topic);
+      stream.next(m.imu_topic);
+      stream.next(m.odometry_topic);
+      stream.next(m.nav_sat_fix_topic);
+      stream.next(m.landmark_topic);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct SensorTopics_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::cartographer_ros_msgs::SensorTopics_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::cartographer_ros_msgs::SensorTopics_<ContainerAllocator>& v)
+  {
+    s << indent << "laser_scan_topic: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + "  ", v.laser_scan_topic);
+    s << indent << "multi_echo_laser_scan_topic: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + "  ", v.multi_echo_laser_scan_topic);
+    s << indent << "point_cloud2_topic: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + "  ", v.point_cloud2_topic);
+    s << indent << "imu_topic: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + "  ", v.imu_topic);
+    s << indent << "odometry_topic: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + "  ", v.odometry_topic);
+    s << indent << "nav_sat_fix_topic: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + "  ", v.nav_sat_fix_topic);
+    s << indent << "landmark_topic: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + "  ", v.landmark_topic);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // CARTOGRAPHER_ROS_MSGS_MESSAGE_SENSORTOPICS_H

devel/include/cartographer_ros_msgs/StartTrajectory.h

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

devel/include/cartographer_ros_msgs/StartTrajectoryRequest.h

@@ -0,0 +1,276 @@
+// Generated by gencpp from file cartographer_ros_msgs/StartTrajectoryRequest.msg
+// DO NOT EDIT!
+
+
+#ifndef CARTOGRAPHER_ROS_MSGS_MESSAGE_STARTTRAJECTORYREQUEST_H
+#define CARTOGRAPHER_ROS_MSGS_MESSAGE_STARTTRAJECTORYREQUEST_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <cartographer_ros_msgs/TrajectoryOptions.h>
+#include <cartographer_ros_msgs/SensorTopics.h>
+
+namespace cartographer_ros_msgs
+{
+template <class ContainerAllocator>
+struct StartTrajectoryRequest_
+{
+  typedef StartTrajectoryRequest_<ContainerAllocator> Type;
+
+  StartTrajectoryRequest_()
+    : options()
+    , topics()  {
+    }
+  StartTrajectoryRequest_(const ContainerAllocator& _alloc)
+    : options(_alloc)
+    , topics(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::cartographer_ros_msgs::TrajectoryOptions_<ContainerAllocator>  _options_type;
+  _options_type options;
+
+   typedef  ::cartographer_ros_msgs::SensorTopics_<ContainerAllocator>  _topics_type;
+  _topics_type topics;
+
+
+
+
+
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::StartTrajectoryRequest_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::StartTrajectoryRequest_<ContainerAllocator> const> ConstPtr;
+
+}; // struct StartTrajectoryRequest_
+
+typedef ::cartographer_ros_msgs::StartTrajectoryRequest_<std::allocator<void> > StartTrajectoryRequest;
+
+typedef boost::shared_ptr< ::cartographer_ros_msgs::StartTrajectoryRequest > StartTrajectoryRequestPtr;
+typedef boost::shared_ptr< ::cartographer_ros_msgs::StartTrajectoryRequest const> StartTrajectoryRequestConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::cartographer_ros_msgs::StartTrajectoryRequest_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::cartographer_ros_msgs::StartTrajectoryRequest_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace cartographer_ros_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'cartographer_ros_msgs': ['/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_ros_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::StartTrajectoryRequest_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::StartTrajectoryRequest_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::StartTrajectoryRequest_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::StartTrajectoryRequest_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::StartTrajectoryRequest_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::StartTrajectoryRequest_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::cartographer_ros_msgs::StartTrajectoryRequest_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "0780da312468afe59b45454db35b17ed";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::StartTrajectoryRequest_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x0780da312468afe5ULL;
+  static const uint64_t static_value2 = 0x9b45454db35b17edULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::cartographer_ros_msgs::StartTrajectoryRequest_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/StartTrajectoryRequest";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::StartTrajectoryRequest_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::cartographer_ros_msgs::StartTrajectoryRequest_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+cartographer_ros_msgs/TrajectoryOptions options\n\
+cartographer_ros_msgs/SensorTopics topics\n\
+\n\
+================================================================================\n\
+MSG: cartographer_ros_msgs/TrajectoryOptions\n\
+# Copyright 2016 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+string tracking_frame\n\
+string published_frame\n\
+string odom_frame\n\
+bool provide_odom_frame\n\
+bool use_odometry\n\
+bool use_nav_sat\n\
+bool use_landmarks\n\
+bool publish_frame_projected_to_2d\n\
+int32 num_laser_scans\n\
+int32 num_multi_echo_laser_scans\n\
+int32 num_subdivisions_per_laser_scan\n\
+int32 num_point_clouds\n\
+float64 rangefinder_sampling_ratio\n\
+float64 odometry_sampling_ratio\n\
+float64 fixed_frame_pose_sampling_ratio\n\
+float64 imu_sampling_ratio\n\
+float64 landmarks_sampling_ratio\n\
+\n\
+# This is a binary-encoded\n\
+# 'cartographer.mapping.proto.TrajectoryBuilderOptions' proto.\n\
+string trajectory_builder_options_proto\n\
+\n\
+================================================================================\n\
+MSG: cartographer_ros_msgs/SensorTopics\n\
+# Copyright 2016 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+string laser_scan_topic\n\
+string multi_echo_laser_scan_topic\n\
+string point_cloud2_topic\n\
+string imu_topic\n\
+string odometry_topic\n\
+string nav_sat_fix_topic\n\
+string landmark_topic\n\
+";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::StartTrajectoryRequest_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::cartographer_ros_msgs::StartTrajectoryRequest_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.options);
+      stream.next(m.topics);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct StartTrajectoryRequest_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::cartographer_ros_msgs::StartTrajectoryRequest_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::cartographer_ros_msgs::StartTrajectoryRequest_<ContainerAllocator>& v)
+  {
+    s << indent << "options: ";
+    s << std::endl;
+    Printer< ::cartographer_ros_msgs::TrajectoryOptions_<ContainerAllocator> >::stream(s, indent + "  ", v.options);
+    s << indent << "topics: ";
+    s << std::endl;
+    Printer< ::cartographer_ros_msgs::SensorTopics_<ContainerAllocator> >::stream(s, indent + "  ", v.topics);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // CARTOGRAPHER_ROS_MSGS_MESSAGE_STARTTRAJECTORYREQUEST_H

devel/include/cartographer_ros_msgs/StartTrajectoryResponse.h

@@ -0,0 +1,219 @@
+// Generated by gencpp from file cartographer_ros_msgs/StartTrajectoryResponse.msg
+// DO NOT EDIT!
+
+
+#ifndef CARTOGRAPHER_ROS_MSGS_MESSAGE_STARTTRAJECTORYRESPONSE_H
+#define CARTOGRAPHER_ROS_MSGS_MESSAGE_STARTTRAJECTORYRESPONSE_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <cartographer_ros_msgs/StatusResponse.h>
+
+namespace cartographer_ros_msgs
+{
+template <class ContainerAllocator>
+struct StartTrajectoryResponse_
+{
+  typedef StartTrajectoryResponse_<ContainerAllocator> Type;
+
+  StartTrajectoryResponse_()
+    : status()
+    , trajectory_id(0)  {
+    }
+  StartTrajectoryResponse_(const ContainerAllocator& _alloc)
+    : status(_alloc)
+    , trajectory_id(0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator>  _status_type;
+  _status_type status;
+
+   typedef int32_t _trajectory_id_type;
+  _trajectory_id_type trajectory_id;
+
+
+
+
+
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::StartTrajectoryResponse_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::StartTrajectoryResponse_<ContainerAllocator> const> ConstPtr;
+
+}; // struct StartTrajectoryResponse_
+
+typedef ::cartographer_ros_msgs::StartTrajectoryResponse_<std::allocator<void> > StartTrajectoryResponse;
+
+typedef boost::shared_ptr< ::cartographer_ros_msgs::StartTrajectoryResponse > StartTrajectoryResponsePtr;
+typedef boost::shared_ptr< ::cartographer_ros_msgs::StartTrajectoryResponse const> StartTrajectoryResponseConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::cartographer_ros_msgs::StartTrajectoryResponse_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::cartographer_ros_msgs::StartTrajectoryResponse_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace cartographer_ros_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'cartographer_ros_msgs': ['/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_ros_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::StartTrajectoryResponse_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::StartTrajectoryResponse_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::StartTrajectoryResponse_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::StartTrajectoryResponse_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::StartTrajectoryResponse_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::StartTrajectoryResponse_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::cartographer_ros_msgs::StartTrajectoryResponse_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "a14602d76d9b734b374a25be319cdbe9";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::StartTrajectoryResponse_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0xa14602d76d9b734bULL;
+  static const uint64_t static_value2 = 0x374a25be319cdbe9ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::cartographer_ros_msgs::StartTrajectoryResponse_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/StartTrajectoryResponse";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::StartTrajectoryResponse_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::cartographer_ros_msgs::StartTrajectoryResponse_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/StatusResponse status\n\
+int32 trajectory_id\n\
+\n\
+\n\
+================================================================================\n\
+MSG: cartographer_ros_msgs/StatusResponse\n\
+# Copyright 2018 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+# A common message type to indicate the outcome of a service call.\n\
+uint8 code\n\
+string message\n\
+";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::StartTrajectoryResponse_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::cartographer_ros_msgs::StartTrajectoryResponse_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.status);
+      stream.next(m.trajectory_id);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct StartTrajectoryResponse_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::cartographer_ros_msgs::StartTrajectoryResponse_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::cartographer_ros_msgs::StartTrajectoryResponse_<ContainerAllocator>& v)
+  {
+    s << indent << "status: ";
+    s << std::endl;
+    Printer< ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator> >::stream(s, indent + "  ", v.status);
+    s << indent << "trajectory_id: ";
+    Printer<int32_t>::stream(s, indent + "  ", v.trajectory_id);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // CARTOGRAPHER_ROS_MSGS_MESSAGE_STARTTRAJECTORYRESPONSE_H

devel/include/cartographer_ros_msgs/StatusCode.h

@@ -0,0 +1,260 @@
+// Generated by gencpp from file cartographer_ros_msgs/StatusCode.msg
+// DO NOT EDIT!
+
+
+#ifndef CARTOGRAPHER_ROS_MSGS_MESSAGE_STATUSCODE_H
+#define CARTOGRAPHER_ROS_MSGS_MESSAGE_STATUSCODE_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+
+namespace cartographer_ros_msgs
+{
+template <class ContainerAllocator>
+struct StatusCode_
+{
+  typedef StatusCode_<ContainerAllocator> Type;
+
+  StatusCode_()
+    {
+    }
+  StatusCode_(const ContainerAllocator& _alloc)
+    {
+  (void)_alloc;
+    }
+
+
+
+
+
+  enum {
+    OK = 0u,
+    CANCELLED = 1u,
+    UNKNOWN = 2u,
+    INVALID_ARGUMENT = 3u,
+    DEADLINE_EXCEEDED = 4u,
+    NOT_FOUND = 5u,
+    ALREADY_EXISTS = 6u,
+    PERMISSION_DENIED = 7u,
+    RESOURCE_EXHAUSTED = 8u,
+    FAILED_PRECONDITION = 9u,
+    ABORTED = 10u,
+    OUT_OF_RANGE = 11u,
+    UNIMPLEMENTED = 12u,
+    INTERNAL = 13u,
+    UNAVAILABLE = 14u,
+    DATA_LOSS = 15u,
+  };
+
+
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::StatusCode_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::StatusCode_<ContainerAllocator> const> ConstPtr;
+
+}; // struct StatusCode_
+
+typedef ::cartographer_ros_msgs::StatusCode_<std::allocator<void> > StatusCode;
+
+typedef boost::shared_ptr< ::cartographer_ros_msgs::StatusCode > StatusCodePtr;
+typedef boost::shared_ptr< ::cartographer_ros_msgs::StatusCode const> StatusCodeConstPtr;
+
+// constants requiring out of line definition
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+   
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::cartographer_ros_msgs::StatusCode_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::cartographer_ros_msgs::StatusCode_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace cartographer_ros_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'cartographer_ros_msgs': ['/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_ros_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::StatusCode_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::StatusCode_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::StatusCode_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::StatusCode_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::StatusCode_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::StatusCode_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::cartographer_ros_msgs::StatusCode_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "90c460dc6da71af1a19af6615a8dc9a4";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::StatusCode_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x90c460dc6da71af1ULL;
+  static const uint64_t static_value2 = 0xa19af6615a8dc9a4ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::cartographer_ros_msgs::StatusCode_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/StatusCode";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::StatusCode_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::cartographer_ros_msgs::StatusCode_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# Copyright 2018 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+# Definition of status code constants equivalent to the gRPC API.\n\
+# https://developers.google.com/maps-booking/reference/grpc-api/status_codes\n\
+uint8 OK=0\n\
+uint8 CANCELLED=1\n\
+uint8 UNKNOWN=2\n\
+uint8 INVALID_ARGUMENT=3\n\
+uint8 DEADLINE_EXCEEDED=4\n\
+uint8 NOT_FOUND=5\n\
+uint8 ALREADY_EXISTS=6\n\
+uint8 PERMISSION_DENIED=7\n\
+uint8 RESOURCE_EXHAUSTED=8\n\
+uint8 FAILED_PRECONDITION=9\n\
+uint8 ABORTED=10\n\
+uint8 OUT_OF_RANGE=11\n\
+uint8 UNIMPLEMENTED=12\n\
+uint8 INTERNAL=13\n\
+uint8 UNAVAILABLE=14\n\
+uint8 DATA_LOSS=15\n\
+";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::StatusCode_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::cartographer_ros_msgs::StatusCode_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream&, T)
+    {}
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct StatusCode_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::cartographer_ros_msgs::StatusCode_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream&, const std::string&, const ::cartographer_ros_msgs::StatusCode_<ContainerAllocator>&)
+  {}
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // CARTOGRAPHER_ROS_MSGS_MESSAGE_STATUSCODE_H

devel/include/cartographer_ros_msgs/StatusResponse.h

@@ -0,0 +1,211 @@
+// Generated by gencpp from file cartographer_ros_msgs/StatusResponse.msg
+// DO NOT EDIT!
+
+
+#ifndef CARTOGRAPHER_ROS_MSGS_MESSAGE_STATUSRESPONSE_H
+#define CARTOGRAPHER_ROS_MSGS_MESSAGE_STATUSRESPONSE_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+
+namespace cartographer_ros_msgs
+{
+template <class ContainerAllocator>
+struct StatusResponse_
+{
+  typedef StatusResponse_<ContainerAllocator> Type;
+
+  StatusResponse_()
+    : code(0)
+    , message()  {
+    }
+  StatusResponse_(const ContainerAllocator& _alloc)
+    : code(0)
+    , message(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef uint8_t _code_type;
+  _code_type code;
+
+   typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _message_type;
+  _message_type message;
+
+
+
+
+
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator> const> ConstPtr;
+
+}; // struct StatusResponse_
+
+typedef ::cartographer_ros_msgs::StatusResponse_<std::allocator<void> > StatusResponse;
+
+typedef boost::shared_ptr< ::cartographer_ros_msgs::StatusResponse > StatusResponsePtr;
+typedef boost::shared_ptr< ::cartographer_ros_msgs::StatusResponse const> StatusResponseConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace cartographer_ros_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'cartographer_ros_msgs': ['/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_ros_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "f45eaca0a8effd52a8b18d39434a6627";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0xf45eaca0a8effd52ULL;
+  static const uint64_t static_value2 = 0xa8b18d39434a6627ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/StatusResponse";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# Copyright 2018 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+# A common message type to indicate the outcome of a service call.\n\
+uint8 code\n\
+string message\n\
+";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.code);
+      stream.next(m.message);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct StatusResponse_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator>& v)
+  {
+    s << indent << "code: ";
+    Printer<uint8_t>::stream(s, indent + "  ", v.code);
+    s << indent << "message: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + "  ", v.message);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // CARTOGRAPHER_ROS_MSGS_MESSAGE_STATUSRESPONSE_H

devel/include/cartographer_ros_msgs/SubmapEntry.h

@@ -0,0 +1,261 @@
+// Generated by gencpp from file cartographer_ros_msgs/SubmapEntry.msg
+// DO NOT EDIT!
+
+
+#ifndef CARTOGRAPHER_ROS_MSGS_MESSAGE_SUBMAPENTRY_H
+#define CARTOGRAPHER_ROS_MSGS_MESSAGE_SUBMAPENTRY_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <geometry_msgs/Pose.h>
+
+namespace cartographer_ros_msgs
+{
+template <class ContainerAllocator>
+struct SubmapEntry_
+{
+  typedef SubmapEntry_<ContainerAllocator> Type;
+
+  SubmapEntry_()
+    : trajectory_id(0)
+    , submap_index(0)
+    , submap_version(0)
+    , pose()
+    , is_frozen(false)  {
+    }
+  SubmapEntry_(const ContainerAllocator& _alloc)
+    : trajectory_id(0)
+    , submap_index(0)
+    , submap_version(0)
+    , pose(_alloc)
+    , is_frozen(false)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef int32_t _trajectory_id_type;
+  _trajectory_id_type trajectory_id;
+
+   typedef int32_t _submap_index_type;
+  _submap_index_type submap_index;
+
+   typedef int32_t _submap_version_type;
+  _submap_version_type submap_version;
+
+   typedef  ::geometry_msgs::Pose_<ContainerAllocator>  _pose_type;
+  _pose_type pose;
+
+   typedef uint8_t _is_frozen_type;
+  _is_frozen_type is_frozen;
+
+
+
+
+
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::SubmapEntry_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::SubmapEntry_<ContainerAllocator> const> ConstPtr;
+
+}; // struct SubmapEntry_
+
+typedef ::cartographer_ros_msgs::SubmapEntry_<std::allocator<void> > SubmapEntry;
+
+typedef boost::shared_ptr< ::cartographer_ros_msgs::SubmapEntry > SubmapEntryPtr;
+typedef boost::shared_ptr< ::cartographer_ros_msgs::SubmapEntry const> SubmapEntryConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::cartographer_ros_msgs::SubmapEntry_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::cartographer_ros_msgs::SubmapEntry_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace cartographer_ros_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'cartographer_ros_msgs': ['/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_ros_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::SubmapEntry_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::SubmapEntry_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::SubmapEntry_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::SubmapEntry_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::SubmapEntry_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::SubmapEntry_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::cartographer_ros_msgs::SubmapEntry_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "0b064ac06b4af2be11388441508c9572";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::SubmapEntry_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x0b064ac06b4af2beULL;
+  static const uint64_t static_value2 = 0x11388441508c9572ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::cartographer_ros_msgs::SubmapEntry_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/SubmapEntry";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::SubmapEntry_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::cartographer_ros_msgs::SubmapEntry_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# Copyright 2016 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+int32 trajectory_id\n\
+int32 submap_index\n\
+int32 submap_version\n\
+geometry_msgs/Pose pose\n\
+bool is_frozen\n\
+\n\
+================================================================================\n\
+MSG: geometry_msgs/Pose\n\
+# A representation of pose in free space, composed of position and orientation. \n\
+Point position\n\
+Quaternion orientation\n\
+\n\
+================================================================================\n\
+MSG: geometry_msgs/Point\n\
+# This contains the position of a point in free space\n\
+float64 x\n\
+float64 y\n\
+float64 z\n\
+\n\
+================================================================================\n\
+MSG: geometry_msgs/Quaternion\n\
+# This represents an orientation in free space in quaternion form.\n\
+\n\
+float64 x\n\
+float64 y\n\
+float64 z\n\
+float64 w\n\
+";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::SubmapEntry_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::cartographer_ros_msgs::SubmapEntry_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.trajectory_id);
+      stream.next(m.submap_index);
+      stream.next(m.submap_version);
+      stream.next(m.pose);
+      stream.next(m.is_frozen);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct SubmapEntry_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::cartographer_ros_msgs::SubmapEntry_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::cartographer_ros_msgs::SubmapEntry_<ContainerAllocator>& v)
+  {
+    s << indent << "trajectory_id: ";
+    Printer<int32_t>::stream(s, indent + "  ", v.trajectory_id);
+    s << indent << "submap_index: ";
+    Printer<int32_t>::stream(s, indent + "  ", v.submap_index);
+    s << indent << "submap_version: ";
+    Printer<int32_t>::stream(s, indent + "  ", v.submap_version);
+    s << indent << "pose: ";
+    s << std::endl;
+    Printer< ::geometry_msgs::Pose_<ContainerAllocator> >::stream(s, indent + "  ", v.pose);
+    s << indent << "is_frozen: ";
+    Printer<uint8_t>::stream(s, indent + "  ", v.is_frozen);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // CARTOGRAPHER_ROS_MSGS_MESSAGE_SUBMAPENTRY_H

devel/include/cartographer_ros_msgs/SubmapList.h

@@ -0,0 +1,281 @@
+// Generated by gencpp from file cartographer_ros_msgs/SubmapList.msg
+// DO NOT EDIT!
+
+
+#ifndef CARTOGRAPHER_ROS_MSGS_MESSAGE_SUBMAPLIST_H
+#define CARTOGRAPHER_ROS_MSGS_MESSAGE_SUBMAPLIST_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <std_msgs/Header.h>
+#include <cartographer_ros_msgs/SubmapEntry.h>
+
+namespace cartographer_ros_msgs
+{
+template <class ContainerAllocator>
+struct SubmapList_
+{
+  typedef SubmapList_<ContainerAllocator> Type;
+
+  SubmapList_()
+    : header()
+    , submap()  {
+    }
+  SubmapList_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , submap(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
+  _header_type header;
+
+   typedef std::vector< ::cartographer_ros_msgs::SubmapEntry_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::cartographer_ros_msgs::SubmapEntry_<ContainerAllocator> >::other >  _submap_type;
+  _submap_type submap;
+
+
+
+
+
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::SubmapList_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::SubmapList_<ContainerAllocator> const> ConstPtr;
+
+}; // struct SubmapList_
+
+typedef ::cartographer_ros_msgs::SubmapList_<std::allocator<void> > SubmapList;
+
+typedef boost::shared_ptr< ::cartographer_ros_msgs::SubmapList > SubmapListPtr;
+typedef boost::shared_ptr< ::cartographer_ros_msgs::SubmapList const> SubmapListConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::cartographer_ros_msgs::SubmapList_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::cartographer_ros_msgs::SubmapList_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace cartographer_ros_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True}
+// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'cartographer_ros_msgs': ['/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_ros_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::SubmapList_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::SubmapList_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::SubmapList_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::SubmapList_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::SubmapList_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::SubmapList_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::cartographer_ros_msgs::SubmapList_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "73b1e412208f0787050395996f6143db";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::SubmapList_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x73b1e412208f0787ULL;
+  static const uint64_t static_value2 = 0x050395996f6143dbULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::cartographer_ros_msgs::SubmapList_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/SubmapList";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::SubmapList_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::cartographer_ros_msgs::SubmapList_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# Copyright 2016 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+std_msgs/Header header\n\
+cartographer_ros_msgs/SubmapEntry[] submap\n\
+\n\
+================================================================================\n\
+MSG: std_msgs/Header\n\
+# Standard metadata for higher-level stamped data types.\n\
+# This is generally used to communicate timestamped data \n\
+# in a particular coordinate frame.\n\
+# \n\
+# sequence ID: consecutively increasing ID \n\
+uint32 seq\n\
+#Two-integer timestamp that is expressed as:\n\
+# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\
+# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\
+# time-handling sugar is provided by the client library\n\
+time stamp\n\
+#Frame this data is associated with\n\
+# 0: no frame\n\
+# 1: global frame\n\
+string frame_id\n\
+\n\
+================================================================================\n\
+MSG: cartographer_ros_msgs/SubmapEntry\n\
+# Copyright 2016 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+int32 trajectory_id\n\
+int32 submap_index\n\
+int32 submap_version\n\
+geometry_msgs/Pose pose\n\
+bool is_frozen\n\
+\n\
+================================================================================\n\
+MSG: geometry_msgs/Pose\n\
+# A representation of pose in free space, composed of position and orientation. \n\
+Point position\n\
+Quaternion orientation\n\
+\n\
+================================================================================\n\
+MSG: geometry_msgs/Point\n\
+# This contains the position of a point in free space\n\
+float64 x\n\
+float64 y\n\
+float64 z\n\
+\n\
+================================================================================\n\
+MSG: geometry_msgs/Quaternion\n\
+# This represents an orientation in free space in quaternion form.\n\
+\n\
+float64 x\n\
+float64 y\n\
+float64 z\n\
+float64 w\n\
+";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::SubmapList_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::cartographer_ros_msgs::SubmapList_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.header);
+      stream.next(m.submap);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct SubmapList_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::cartographer_ros_msgs::SubmapList_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::cartographer_ros_msgs::SubmapList_<ContainerAllocator>& v)
+  {
+    s << indent << "header: ";
+    s << std::endl;
+    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
+    s << indent << "submap[]" << std::endl;
+    for (size_t i = 0; i < v.submap.size(); ++i)
+    {
+      s << indent << "  submap[" << i << "]: ";
+      s << std::endl;
+      s << indent;
+      Printer< ::cartographer_ros_msgs::SubmapEntry_<ContainerAllocator> >::stream(s, indent + "    ", v.submap[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // CARTOGRAPHER_ROS_MSGS_MESSAGE_SUBMAPLIST_H

devel/include/cartographer_ros_msgs/SubmapQuery.h

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

devel/include/cartographer_ros_msgs/SubmapQueryRequest.h

@@ -0,0 +1,210 @@
+// Generated by gencpp from file cartographer_ros_msgs/SubmapQueryRequest.msg
+// DO NOT EDIT!
+
+
+#ifndef CARTOGRAPHER_ROS_MSGS_MESSAGE_SUBMAPQUERYREQUEST_H
+#define CARTOGRAPHER_ROS_MSGS_MESSAGE_SUBMAPQUERYREQUEST_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+
+namespace cartographer_ros_msgs
+{
+template <class ContainerAllocator>
+struct SubmapQueryRequest_
+{
+  typedef SubmapQueryRequest_<ContainerAllocator> Type;
+
+  SubmapQueryRequest_()
+    : trajectory_id(0)
+    , submap_index(0)  {
+    }
+  SubmapQueryRequest_(const ContainerAllocator& _alloc)
+    : trajectory_id(0)
+    , submap_index(0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef int32_t _trajectory_id_type;
+  _trajectory_id_type trajectory_id;
+
+   typedef int32_t _submap_index_type;
+  _submap_index_type submap_index;
+
+
+
+
+
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::SubmapQueryRequest_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::SubmapQueryRequest_<ContainerAllocator> const> ConstPtr;
+
+}; // struct SubmapQueryRequest_
+
+typedef ::cartographer_ros_msgs::SubmapQueryRequest_<std::allocator<void> > SubmapQueryRequest;
+
+typedef boost::shared_ptr< ::cartographer_ros_msgs::SubmapQueryRequest > SubmapQueryRequestPtr;
+typedef boost::shared_ptr< ::cartographer_ros_msgs::SubmapQueryRequest const> SubmapQueryRequestConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::cartographer_ros_msgs::SubmapQueryRequest_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::cartographer_ros_msgs::SubmapQueryRequest_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace cartographer_ros_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': True, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'cartographer_ros_msgs': ['/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_ros_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::SubmapQueryRequest_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::SubmapQueryRequest_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::SubmapQueryRequest_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::SubmapQueryRequest_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::SubmapQueryRequest_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::SubmapQueryRequest_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::cartographer_ros_msgs::SubmapQueryRequest_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "5fc429a478a6d73822616720a31a2158";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::SubmapQueryRequest_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x5fc429a478a6d738ULL;
+  static const uint64_t static_value2 = 0x22616720a31a2158ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::cartographer_ros_msgs::SubmapQueryRequest_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/SubmapQueryRequest";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::SubmapQueryRequest_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::cartographer_ros_msgs::SubmapQueryRequest_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+int32 trajectory_id\n\
+int32 submap_index\n\
+";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::SubmapQueryRequest_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::cartographer_ros_msgs::SubmapQueryRequest_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.trajectory_id);
+      stream.next(m.submap_index);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct SubmapQueryRequest_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::cartographer_ros_msgs::SubmapQueryRequest_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::cartographer_ros_msgs::SubmapQueryRequest_<ContainerAllocator>& v)
+  {
+    s << indent << "trajectory_id: ";
+    Printer<int32_t>::stream(s, indent + "  ", v.trajectory_id);
+    s << indent << "submap_index: ";
+    Printer<int32_t>::stream(s, indent + "  ", v.submap_index);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // CARTOGRAPHER_ROS_MSGS_MESSAGE_SUBMAPQUERYREQUEST_H

devel/include/cartographer_ros_msgs/SubmapQueryResponse.h

@@ -0,0 +1,279 @@
+// Generated by gencpp from file cartographer_ros_msgs/SubmapQueryResponse.msg
+// DO NOT EDIT!
+
+
+#ifndef CARTOGRAPHER_ROS_MSGS_MESSAGE_SUBMAPQUERYRESPONSE_H
+#define CARTOGRAPHER_ROS_MSGS_MESSAGE_SUBMAPQUERYRESPONSE_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <cartographer_ros_msgs/StatusResponse.h>
+#include <cartographer_ros_msgs/SubmapTexture.h>
+
+namespace cartographer_ros_msgs
+{
+template <class ContainerAllocator>
+struct SubmapQueryResponse_
+{
+  typedef SubmapQueryResponse_<ContainerAllocator> Type;
+
+  SubmapQueryResponse_()
+    : status()
+    , submap_version(0)
+    , textures()  {
+    }
+  SubmapQueryResponse_(const ContainerAllocator& _alloc)
+    : status(_alloc)
+    , submap_version(0)
+    , textures(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator>  _status_type;
+  _status_type status;
+
+   typedef int32_t _submap_version_type;
+  _submap_version_type submap_version;
+
+   typedef std::vector< ::cartographer_ros_msgs::SubmapTexture_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::cartographer_ros_msgs::SubmapTexture_<ContainerAllocator> >::other >  _textures_type;
+  _textures_type textures;
+
+
+
+
+
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::SubmapQueryResponse_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::SubmapQueryResponse_<ContainerAllocator> const> ConstPtr;
+
+}; // struct SubmapQueryResponse_
+
+typedef ::cartographer_ros_msgs::SubmapQueryResponse_<std::allocator<void> > SubmapQueryResponse;
+
+typedef boost::shared_ptr< ::cartographer_ros_msgs::SubmapQueryResponse > SubmapQueryResponsePtr;
+typedef boost::shared_ptr< ::cartographer_ros_msgs::SubmapQueryResponse const> SubmapQueryResponseConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::cartographer_ros_msgs::SubmapQueryResponse_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::cartographer_ros_msgs::SubmapQueryResponse_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace cartographer_ros_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'cartographer_ros_msgs': ['/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_ros_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::SubmapQueryResponse_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::SubmapQueryResponse_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::SubmapQueryResponse_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::SubmapQueryResponse_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::SubmapQueryResponse_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::SubmapQueryResponse_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::cartographer_ros_msgs::SubmapQueryResponse_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "ffc82c14b81fa551bc249c31ba402b2e";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::SubmapQueryResponse_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0xffc82c14b81fa551ULL;
+  static const uint64_t static_value2 = 0xbc249c31ba402b2eULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::cartographer_ros_msgs::SubmapQueryResponse_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/SubmapQueryResponse";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::SubmapQueryResponse_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::cartographer_ros_msgs::SubmapQueryResponse_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/StatusResponse status\n\
+int32 submap_version\n\
+cartographer_ros_msgs/SubmapTexture[] textures\n\
+\n\
+\n\
+================================================================================\n\
+MSG: cartographer_ros_msgs/StatusResponse\n\
+# Copyright 2018 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+# A common message type to indicate the outcome of a service call.\n\
+uint8 code\n\
+string message\n\
+\n\
+================================================================================\n\
+MSG: cartographer_ros_msgs/SubmapTexture\n\
+# Copyright 2017 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+uint8[] cells\n\
+int32 width\n\
+int32 height\n\
+float64 resolution\n\
+geometry_msgs/Pose slice_pose\n\
+\n\
+================================================================================\n\
+MSG: geometry_msgs/Pose\n\
+# A representation of pose in free space, composed of position and orientation. \n\
+Point position\n\
+Quaternion orientation\n\
+\n\
+================================================================================\n\
+MSG: geometry_msgs/Point\n\
+# This contains the position of a point in free space\n\
+float64 x\n\
+float64 y\n\
+float64 z\n\
+\n\
+================================================================================\n\
+MSG: geometry_msgs/Quaternion\n\
+# This represents an orientation in free space in quaternion form.\n\
+\n\
+float64 x\n\
+float64 y\n\
+float64 z\n\
+float64 w\n\
+";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::SubmapQueryResponse_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::cartographer_ros_msgs::SubmapQueryResponse_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.status);
+      stream.next(m.submap_version);
+      stream.next(m.textures);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct SubmapQueryResponse_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::cartographer_ros_msgs::SubmapQueryResponse_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::cartographer_ros_msgs::SubmapQueryResponse_<ContainerAllocator>& v)
+  {
+    s << indent << "status: ";
+    s << std::endl;
+    Printer< ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator> >::stream(s, indent + "  ", v.status);
+    s << indent << "submap_version: ";
+    Printer<int32_t>::stream(s, indent + "  ", v.submap_version);
+    s << indent << "textures[]" << std::endl;
+    for (size_t i = 0; i < v.textures.size(); ++i)
+    {
+      s << indent << "  textures[" << i << "]: ";
+      s << std::endl;
+      s << indent;
+      Printer< ::cartographer_ros_msgs::SubmapTexture_<ContainerAllocator> >::stream(s, indent + "    ", v.textures[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // CARTOGRAPHER_ROS_MSGS_MESSAGE_SUBMAPQUERYRESPONSE_H

devel/include/cartographer_ros_msgs/SubmapTexture.h

@@ -0,0 +1,265 @@
+// Generated by gencpp from file cartographer_ros_msgs/SubmapTexture.msg
+// DO NOT EDIT!
+
+
+#ifndef CARTOGRAPHER_ROS_MSGS_MESSAGE_SUBMAPTEXTURE_H
+#define CARTOGRAPHER_ROS_MSGS_MESSAGE_SUBMAPTEXTURE_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <geometry_msgs/Pose.h>
+
+namespace cartographer_ros_msgs
+{
+template <class ContainerAllocator>
+struct SubmapTexture_
+{
+  typedef SubmapTexture_<ContainerAllocator> Type;
+
+  SubmapTexture_()
+    : cells()
+    , width(0)
+    , height(0)
+    , resolution(0.0)
+    , slice_pose()  {
+    }
+  SubmapTexture_(const ContainerAllocator& _alloc)
+    : cells(_alloc)
+    , width(0)
+    , height(0)
+    , resolution(0.0)
+    , slice_pose(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef std::vector<uint8_t, typename ContainerAllocator::template rebind<uint8_t>::other >  _cells_type;
+  _cells_type cells;
+
+   typedef int32_t _width_type;
+  _width_type width;
+
+   typedef int32_t _height_type;
+  _height_type height;
+
+   typedef double _resolution_type;
+  _resolution_type resolution;
+
+   typedef  ::geometry_msgs::Pose_<ContainerAllocator>  _slice_pose_type;
+  _slice_pose_type slice_pose;
+
+
+
+
+
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::SubmapTexture_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::SubmapTexture_<ContainerAllocator> const> ConstPtr;
+
+}; // struct SubmapTexture_
+
+typedef ::cartographer_ros_msgs::SubmapTexture_<std::allocator<void> > SubmapTexture;
+
+typedef boost::shared_ptr< ::cartographer_ros_msgs::SubmapTexture > SubmapTexturePtr;
+typedef boost::shared_ptr< ::cartographer_ros_msgs::SubmapTexture const> SubmapTextureConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::cartographer_ros_msgs::SubmapTexture_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::cartographer_ros_msgs::SubmapTexture_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace cartographer_ros_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'cartographer_ros_msgs': ['/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_ros_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::SubmapTexture_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::SubmapTexture_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::SubmapTexture_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::SubmapTexture_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::SubmapTexture_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::SubmapTexture_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::cartographer_ros_msgs::SubmapTexture_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "26187fc048d2d8e578b6c781f3b53158";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::SubmapTexture_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x26187fc048d2d8e5ULL;
+  static const uint64_t static_value2 = 0x78b6c781f3b53158ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::cartographer_ros_msgs::SubmapTexture_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/SubmapTexture";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::SubmapTexture_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::cartographer_ros_msgs::SubmapTexture_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# Copyright 2017 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+uint8[] cells\n\
+int32 width\n\
+int32 height\n\
+float64 resolution\n\
+geometry_msgs/Pose slice_pose\n\
+\n\
+================================================================================\n\
+MSG: geometry_msgs/Pose\n\
+# A representation of pose in free space, composed of position and orientation. \n\
+Point position\n\
+Quaternion orientation\n\
+\n\
+================================================================================\n\
+MSG: geometry_msgs/Point\n\
+# This contains the position of a point in free space\n\
+float64 x\n\
+float64 y\n\
+float64 z\n\
+\n\
+================================================================================\n\
+MSG: geometry_msgs/Quaternion\n\
+# This represents an orientation in free space in quaternion form.\n\
+\n\
+float64 x\n\
+float64 y\n\
+float64 z\n\
+float64 w\n\
+";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::SubmapTexture_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::cartographer_ros_msgs::SubmapTexture_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.cells);
+      stream.next(m.width);
+      stream.next(m.height);
+      stream.next(m.resolution);
+      stream.next(m.slice_pose);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct SubmapTexture_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::cartographer_ros_msgs::SubmapTexture_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::cartographer_ros_msgs::SubmapTexture_<ContainerAllocator>& v)
+  {
+    s << indent << "cells[]" << std::endl;
+    for (size_t i = 0; i < v.cells.size(); ++i)
+    {
+      s << indent << "  cells[" << i << "]: ";
+      Printer<uint8_t>::stream(s, indent + "  ", v.cells[i]);
+    }
+    s << indent << "width: ";
+    Printer<int32_t>::stream(s, indent + "  ", v.width);
+    s << indent << "height: ";
+    Printer<int32_t>::stream(s, indent + "  ", v.height);
+    s << indent << "resolution: ";
+    Printer<double>::stream(s, indent + "  ", v.resolution);
+    s << indent << "slice_pose: ";
+    s << std::endl;
+    Printer< ::geometry_msgs::Pose_<ContainerAllocator> >::stream(s, indent + "  ", v.slice_pose);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // CARTOGRAPHER_ROS_MSGS_MESSAGE_SUBMAPTEXTURE_H

devel/include/cartographer_ros_msgs/TrajectoryOptions.h

@@ -0,0 +1,357 @@
+// Generated by gencpp from file cartographer_ros_msgs/TrajectoryOptions.msg
+// DO NOT EDIT!
+
+
+#ifndef CARTOGRAPHER_ROS_MSGS_MESSAGE_TRAJECTORYOPTIONS_H
+#define CARTOGRAPHER_ROS_MSGS_MESSAGE_TRAJECTORYOPTIONS_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+
+namespace cartographer_ros_msgs
+{
+template <class ContainerAllocator>
+struct TrajectoryOptions_
+{
+  typedef TrajectoryOptions_<ContainerAllocator> Type;
+
+  TrajectoryOptions_()
+    : tracking_frame()
+    , published_frame()
+    , odom_frame()
+    , provide_odom_frame(false)
+    , use_odometry(false)
+    , use_nav_sat(false)
+    , use_landmarks(false)
+    , publish_frame_projected_to_2d(false)
+    , num_laser_scans(0)
+    , num_multi_echo_laser_scans(0)
+    , num_subdivisions_per_laser_scan(0)
+    , num_point_clouds(0)
+    , rangefinder_sampling_ratio(0.0)
+    , odometry_sampling_ratio(0.0)
+    , fixed_frame_pose_sampling_ratio(0.0)
+    , imu_sampling_ratio(0.0)
+    , landmarks_sampling_ratio(0.0)
+    , trajectory_builder_options_proto()  {
+    }
+  TrajectoryOptions_(const ContainerAllocator& _alloc)
+    : tracking_frame(_alloc)
+    , published_frame(_alloc)
+    , odom_frame(_alloc)
+    , provide_odom_frame(false)
+    , use_odometry(false)
+    , use_nav_sat(false)
+    , use_landmarks(false)
+    , publish_frame_projected_to_2d(false)
+    , num_laser_scans(0)
+    , num_multi_echo_laser_scans(0)
+    , num_subdivisions_per_laser_scan(0)
+    , num_point_clouds(0)
+    , rangefinder_sampling_ratio(0.0)
+    , odometry_sampling_ratio(0.0)
+    , fixed_frame_pose_sampling_ratio(0.0)
+    , imu_sampling_ratio(0.0)
+    , landmarks_sampling_ratio(0.0)
+    , trajectory_builder_options_proto(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _tracking_frame_type;
+  _tracking_frame_type tracking_frame;
+
+   typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _published_frame_type;
+  _published_frame_type published_frame;
+
+   typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _odom_frame_type;
+  _odom_frame_type odom_frame;
+
+   typedef uint8_t _provide_odom_frame_type;
+  _provide_odom_frame_type provide_odom_frame;
+
+   typedef uint8_t _use_odometry_type;
+  _use_odometry_type use_odometry;
+
+   typedef uint8_t _use_nav_sat_type;
+  _use_nav_sat_type use_nav_sat;
+
+   typedef uint8_t _use_landmarks_type;
+  _use_landmarks_type use_landmarks;
+
+   typedef uint8_t _publish_frame_projected_to_2d_type;
+  _publish_frame_projected_to_2d_type publish_frame_projected_to_2d;
+
+   typedef int32_t _num_laser_scans_type;
+  _num_laser_scans_type num_laser_scans;
+
+   typedef int32_t _num_multi_echo_laser_scans_type;
+  _num_multi_echo_laser_scans_type num_multi_echo_laser_scans;
+
+   typedef int32_t _num_subdivisions_per_laser_scan_type;
+  _num_subdivisions_per_laser_scan_type num_subdivisions_per_laser_scan;
+
+   typedef int32_t _num_point_clouds_type;
+  _num_point_clouds_type num_point_clouds;
+
+   typedef double _rangefinder_sampling_ratio_type;
+  _rangefinder_sampling_ratio_type rangefinder_sampling_ratio;
+
+   typedef double _odometry_sampling_ratio_type;
+  _odometry_sampling_ratio_type odometry_sampling_ratio;
+
+   typedef double _fixed_frame_pose_sampling_ratio_type;
+  _fixed_frame_pose_sampling_ratio_type fixed_frame_pose_sampling_ratio;
+
+   typedef double _imu_sampling_ratio_type;
+  _imu_sampling_ratio_type imu_sampling_ratio;
+
+   typedef double _landmarks_sampling_ratio_type;
+  _landmarks_sampling_ratio_type landmarks_sampling_ratio;
+
+   typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _trajectory_builder_options_proto_type;
+  _trajectory_builder_options_proto_type trajectory_builder_options_proto;
+
+
+
+
+
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::TrajectoryOptions_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::TrajectoryOptions_<ContainerAllocator> const> ConstPtr;
+
+}; // struct TrajectoryOptions_
+
+typedef ::cartographer_ros_msgs::TrajectoryOptions_<std::allocator<void> > TrajectoryOptions;
+
+typedef boost::shared_ptr< ::cartographer_ros_msgs::TrajectoryOptions > TrajectoryOptionsPtr;
+typedef boost::shared_ptr< ::cartographer_ros_msgs::TrajectoryOptions const> TrajectoryOptionsConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::cartographer_ros_msgs::TrajectoryOptions_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::cartographer_ros_msgs::TrajectoryOptions_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace cartographer_ros_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'cartographer_ros_msgs': ['/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_ros_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::TrajectoryOptions_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::TrajectoryOptions_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::TrajectoryOptions_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::TrajectoryOptions_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::TrajectoryOptions_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::TrajectoryOptions_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::cartographer_ros_msgs::TrajectoryOptions_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "7eda9b62c16c18fa1563587e73501e47";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::TrajectoryOptions_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x7eda9b62c16c18faULL;
+  static const uint64_t static_value2 = 0x1563587e73501e47ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::cartographer_ros_msgs::TrajectoryOptions_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/TrajectoryOptions";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::TrajectoryOptions_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::cartographer_ros_msgs::TrajectoryOptions_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# Copyright 2016 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+string tracking_frame\n\
+string published_frame\n\
+string odom_frame\n\
+bool provide_odom_frame\n\
+bool use_odometry\n\
+bool use_nav_sat\n\
+bool use_landmarks\n\
+bool publish_frame_projected_to_2d\n\
+int32 num_laser_scans\n\
+int32 num_multi_echo_laser_scans\n\
+int32 num_subdivisions_per_laser_scan\n\
+int32 num_point_clouds\n\
+float64 rangefinder_sampling_ratio\n\
+float64 odometry_sampling_ratio\n\
+float64 fixed_frame_pose_sampling_ratio\n\
+float64 imu_sampling_ratio\n\
+float64 landmarks_sampling_ratio\n\
+\n\
+# This is a binary-encoded\n\
+# 'cartographer.mapping.proto.TrajectoryBuilderOptions' proto.\n\
+string trajectory_builder_options_proto\n\
+";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::TrajectoryOptions_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::cartographer_ros_msgs::TrajectoryOptions_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.tracking_frame);
+      stream.next(m.published_frame);
+      stream.next(m.odom_frame);
+      stream.next(m.provide_odom_frame);
+      stream.next(m.use_odometry);
+      stream.next(m.use_nav_sat);
+      stream.next(m.use_landmarks);
+      stream.next(m.publish_frame_projected_to_2d);
+      stream.next(m.num_laser_scans);
+      stream.next(m.num_multi_echo_laser_scans);
+      stream.next(m.num_subdivisions_per_laser_scan);
+      stream.next(m.num_point_clouds);
+      stream.next(m.rangefinder_sampling_ratio);
+      stream.next(m.odometry_sampling_ratio);
+      stream.next(m.fixed_frame_pose_sampling_ratio);
+      stream.next(m.imu_sampling_ratio);
+      stream.next(m.landmarks_sampling_ratio);
+      stream.next(m.trajectory_builder_options_proto);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct TrajectoryOptions_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::cartographer_ros_msgs::TrajectoryOptions_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::cartographer_ros_msgs::TrajectoryOptions_<ContainerAllocator>& v)
+  {
+    s << indent << "tracking_frame: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + "  ", v.tracking_frame);
+    s << indent << "published_frame: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + "  ", v.published_frame);
+    s << indent << "odom_frame: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + "  ", v.odom_frame);
+    s << indent << "provide_odom_frame: ";
+    Printer<uint8_t>::stream(s, indent + "  ", v.provide_odom_frame);
+    s << indent << "use_odometry: ";
+    Printer<uint8_t>::stream(s, indent + "  ", v.use_odometry);
+    s << indent << "use_nav_sat: ";
+    Printer<uint8_t>::stream(s, indent + "  ", v.use_nav_sat);
+    s << indent << "use_landmarks: ";
+    Printer<uint8_t>::stream(s, indent + "  ", v.use_landmarks);
+    s << indent << "publish_frame_projected_to_2d: ";
+    Printer<uint8_t>::stream(s, indent + "  ", v.publish_frame_projected_to_2d);
+    s << indent << "num_laser_scans: ";
+    Printer<int32_t>::stream(s, indent + "  ", v.num_laser_scans);
+    s << indent << "num_multi_echo_laser_scans: ";
+    Printer<int32_t>::stream(s, indent + "  ", v.num_multi_echo_laser_scans);
+    s << indent << "num_subdivisions_per_laser_scan: ";
+    Printer<int32_t>::stream(s, indent + "  ", v.num_subdivisions_per_laser_scan);
+    s << indent << "num_point_clouds: ";
+    Printer<int32_t>::stream(s, indent + "  ", v.num_point_clouds);
+    s << indent << "rangefinder_sampling_ratio: ";
+    Printer<double>::stream(s, indent + "  ", v.rangefinder_sampling_ratio);
+    s << indent << "odometry_sampling_ratio: ";
+    Printer<double>::stream(s, indent + "  ", v.odometry_sampling_ratio);
+    s << indent << "fixed_frame_pose_sampling_ratio: ";
+    Printer<double>::stream(s, indent + "  ", v.fixed_frame_pose_sampling_ratio);
+    s << indent << "imu_sampling_ratio: ";
+    Printer<double>::stream(s, indent + "  ", v.imu_sampling_ratio);
+    s << indent << "landmarks_sampling_ratio: ";
+    Printer<double>::stream(s, indent + "  ", v.landmarks_sampling_ratio);
+    s << indent << "trajectory_builder_options_proto: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + "  ", v.trajectory_builder_options_proto);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // CARTOGRAPHER_ROS_MSGS_MESSAGE_TRAJECTORYOPTIONS_H

devel/include/cartographer_ros_msgs/TrajectoryStates.h

@@ -0,0 +1,266 @@
+// Generated by gencpp from file cartographer_ros_msgs/TrajectoryStates.msg
+// DO NOT EDIT!
+
+
+#ifndef CARTOGRAPHER_ROS_MSGS_MESSAGE_TRAJECTORYSTATES_H
+#define CARTOGRAPHER_ROS_MSGS_MESSAGE_TRAJECTORYSTATES_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <std_msgs/Header.h>
+
+namespace cartographer_ros_msgs
+{
+template <class ContainerAllocator>
+struct TrajectoryStates_
+{
+  typedef TrajectoryStates_<ContainerAllocator> Type;
+
+  TrajectoryStates_()
+    : header()
+    , trajectory_id()
+    , trajectory_state()  {
+    }
+  TrajectoryStates_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , trajectory_id(_alloc)
+    , trajectory_state(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
+  _header_type header;
+
+   typedef std::vector<int32_t, typename ContainerAllocator::template rebind<int32_t>::other >  _trajectory_id_type;
+  _trajectory_id_type trajectory_id;
+
+   typedef std::vector<uint8_t, typename ContainerAllocator::template rebind<uint8_t>::other >  _trajectory_state_type;
+  _trajectory_state_type trajectory_state;
+
+
+
+  enum {
+    ACTIVE = 0u,
+    FINISHED = 1u,
+    FROZEN = 2u,
+    DELETED = 3u,
+  };
+
+
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::TrajectoryStates_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::TrajectoryStates_<ContainerAllocator> const> ConstPtr;
+
+}; // struct TrajectoryStates_
+
+typedef ::cartographer_ros_msgs::TrajectoryStates_<std::allocator<void> > TrajectoryStates;
+
+typedef boost::shared_ptr< ::cartographer_ros_msgs::TrajectoryStates > TrajectoryStatesPtr;
+typedef boost::shared_ptr< ::cartographer_ros_msgs::TrajectoryStates const> TrajectoryStatesConstPtr;
+
+// constants requiring out of line definition
+
+   
+
+   
+
+   
+
+   
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::cartographer_ros_msgs::TrajectoryStates_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::cartographer_ros_msgs::TrajectoryStates_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace cartographer_ros_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True}
+// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'cartographer_ros_msgs': ['/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_ros_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::TrajectoryStates_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::TrajectoryStates_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::TrajectoryStates_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::TrajectoryStates_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::TrajectoryStates_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::TrajectoryStates_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::cartographer_ros_msgs::TrajectoryStates_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "85efdd795e95b57a59cb785ecb152345";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::TrajectoryStates_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x85efdd795e95b57aULL;
+  static const uint64_t static_value2 = 0x59cb785ecb152345ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::cartographer_ros_msgs::TrajectoryStates_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/TrajectoryStates";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::TrajectoryStates_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::cartographer_ros_msgs::TrajectoryStates_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# Copyright 2018 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the 'License');\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an 'AS IS' BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+uint8 ACTIVE = 0\n\
+uint8 FINISHED = 1\n\
+uint8 FROZEN = 2\n\
+uint8 DELETED = 3\n\
+\n\
+std_msgs/Header header\n\
+int32[] trajectory_id\n\
+uint8[] trajectory_state\n\
+\n\
+================================================================================\n\
+MSG: std_msgs/Header\n\
+# Standard metadata for higher-level stamped data types.\n\
+# This is generally used to communicate timestamped data \n\
+# in a particular coordinate frame.\n\
+# \n\
+# sequence ID: consecutively increasing ID \n\
+uint32 seq\n\
+#Two-integer timestamp that is expressed as:\n\
+# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\
+# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\
+# time-handling sugar is provided by the client library\n\
+time stamp\n\
+#Frame this data is associated with\n\
+# 0: no frame\n\
+# 1: global frame\n\
+string frame_id\n\
+";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::TrajectoryStates_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::cartographer_ros_msgs::TrajectoryStates_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.header);
+      stream.next(m.trajectory_id);
+      stream.next(m.trajectory_state);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct TrajectoryStates_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::cartographer_ros_msgs::TrajectoryStates_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::cartographer_ros_msgs::TrajectoryStates_<ContainerAllocator>& v)
+  {
+    s << indent << "header: ";
+    s << std::endl;
+    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
+    s << indent << "trajectory_id[]" << std::endl;
+    for (size_t i = 0; i < v.trajectory_id.size(); ++i)
+    {
+      s << indent << "  trajectory_id[" << i << "]: ";
+      Printer<int32_t>::stream(s, indent + "  ", v.trajectory_id[i]);
+    }
+    s << indent << "trajectory_state[]" << std::endl;
+    for (size_t i = 0; i < v.trajectory_state.size(); ++i)
+    {
+      s << indent << "  trajectory_state[" << i << "]: ";
+      Printer<uint8_t>::stream(s, indent + "  ", v.trajectory_state[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // CARTOGRAPHER_ROS_MSGS_MESSAGE_TRAJECTORYSTATES_H

devel/include/cartographer_ros_msgs/TrajectorySubmapList.h

@@ -0,0 +1,249 @@
+// Generated by gencpp from file cartographer_ros_msgs/TrajectorySubmapList.msg
+// DO NOT EDIT!
+
+
+#ifndef CARTOGRAPHER_ROS_MSGS_MESSAGE_TRAJECTORYSUBMAPLIST_H
+#define CARTOGRAPHER_ROS_MSGS_MESSAGE_TRAJECTORYSUBMAPLIST_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <cartographer_ros_msgs/SubmapEntry.h>
+
+namespace cartographer_ros_msgs
+{
+template <class ContainerAllocator>
+struct TrajectorySubmapList_
+{
+  typedef TrajectorySubmapList_<ContainerAllocator> Type;
+
+  TrajectorySubmapList_()
+    : submap()  {
+    }
+  TrajectorySubmapList_(const ContainerAllocator& _alloc)
+    : submap(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef std::vector< ::cartographer_ros_msgs::SubmapEntry_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::cartographer_ros_msgs::SubmapEntry_<ContainerAllocator> >::other >  _submap_type;
+  _submap_type submap;
+
+
+
+
+
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::TrajectorySubmapList_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::TrajectorySubmapList_<ContainerAllocator> const> ConstPtr;
+
+}; // struct TrajectorySubmapList_
+
+typedef ::cartographer_ros_msgs::TrajectorySubmapList_<std::allocator<void> > TrajectorySubmapList;
+
+typedef boost::shared_ptr< ::cartographer_ros_msgs::TrajectorySubmapList > TrajectorySubmapListPtr;
+typedef boost::shared_ptr< ::cartographer_ros_msgs::TrajectorySubmapList const> TrajectorySubmapListConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::cartographer_ros_msgs::TrajectorySubmapList_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::cartographer_ros_msgs::TrajectorySubmapList_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace cartographer_ros_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'cartographer_ros_msgs': ['/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_ros_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::TrajectorySubmapList_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::TrajectorySubmapList_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::TrajectorySubmapList_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::TrajectorySubmapList_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::TrajectorySubmapList_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::TrajectorySubmapList_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::cartographer_ros_msgs::TrajectorySubmapList_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "408b96b1bf0386ee3f0562ab0ff3304a";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::TrajectorySubmapList_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x408b96b1bf0386eeULL;
+  static const uint64_t static_value2 = 0x3f0562ab0ff3304aULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::cartographer_ros_msgs::TrajectorySubmapList_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/TrajectorySubmapList";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::TrajectorySubmapList_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::cartographer_ros_msgs::TrajectorySubmapList_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "# Copyright 2016 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+SubmapEntry[] submap\n\
+\n\
+================================================================================\n\
+MSG: cartographer_ros_msgs/SubmapEntry\n\
+# Copyright 2016 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+uint32 submap_version\n\
+geometry_msgs/Pose pose\n\
+\n\
+================================================================================\n\
+MSG: geometry_msgs/Pose\n\
+# A representation of pose in free space, composed of position and orientation. \n\
+Point position\n\
+Quaternion orientation\n\
+\n\
+================================================================================\n\
+MSG: geometry_msgs/Point\n\
+# This contains the position of a point in free space\n\
+float64 x\n\
+float64 y\n\
+float64 z\n\
+\n\
+================================================================================\n\
+MSG: geometry_msgs/Quaternion\n\
+# This represents an orientation in free space in quaternion form.\n\
+\n\
+float64 x\n\
+float64 y\n\
+float64 z\n\
+float64 w\n\
+";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::TrajectorySubmapList_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::cartographer_ros_msgs::TrajectorySubmapList_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.submap);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct TrajectorySubmapList_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::cartographer_ros_msgs::TrajectorySubmapList_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::cartographer_ros_msgs::TrajectorySubmapList_<ContainerAllocator>& v)
+  {
+    s << indent << "submap[]" << std::endl;
+    for (size_t i = 0; i < v.submap.size(); ++i)
+    {
+      s << indent << "  submap[" << i << "]: ";
+      s << std::endl;
+      s << indent;
+      Printer< ::cartographer_ros_msgs::SubmapEntry_<ContainerAllocator> >::stream(s, indent + "    ", v.submap[i]);
+    }
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // CARTOGRAPHER_ROS_MSGS_MESSAGE_TRAJECTORYSUBMAPLIST_H

devel/include/cartographer_ros_msgs/WriteState.h

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

devel/include/cartographer_ros_msgs/WriteStateRequest.h

@@ -0,0 +1,210 @@
+// Generated by gencpp from file cartographer_ros_msgs/WriteStateRequest.msg
+// DO NOT EDIT!
+
+
+#ifndef CARTOGRAPHER_ROS_MSGS_MESSAGE_WRITESTATEREQUEST_H
+#define CARTOGRAPHER_ROS_MSGS_MESSAGE_WRITESTATEREQUEST_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+
+namespace cartographer_ros_msgs
+{
+template <class ContainerAllocator>
+struct WriteStateRequest_
+{
+  typedef WriteStateRequest_<ContainerAllocator> Type;
+
+  WriteStateRequest_()
+    : filename()
+    , include_unfinished_submaps(false)  {
+    }
+  WriteStateRequest_(const ContainerAllocator& _alloc)
+    : filename(_alloc)
+    , include_unfinished_submaps(false)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _filename_type;
+  _filename_type filename;
+
+   typedef uint8_t _include_unfinished_submaps_type;
+  _include_unfinished_submaps_type include_unfinished_submaps;
+
+
+
+
+
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::WriteStateRequest_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::WriteStateRequest_<ContainerAllocator> const> ConstPtr;
+
+}; // struct WriteStateRequest_
+
+typedef ::cartographer_ros_msgs::WriteStateRequest_<std::allocator<void> > WriteStateRequest;
+
+typedef boost::shared_ptr< ::cartographer_ros_msgs::WriteStateRequest > WriteStateRequestPtr;
+typedef boost::shared_ptr< ::cartographer_ros_msgs::WriteStateRequest const> WriteStateRequestConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::cartographer_ros_msgs::WriteStateRequest_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::cartographer_ros_msgs::WriteStateRequest_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace cartographer_ros_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'cartographer_ros_msgs': ['/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_ros_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::WriteStateRequest_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::WriteStateRequest_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::WriteStateRequest_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::WriteStateRequest_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::WriteStateRequest_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::WriteStateRequest_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::cartographer_ros_msgs::WriteStateRequest_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "bfd12117d83df4fe52e78631c0c6b702";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::WriteStateRequest_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0xbfd12117d83df4feULL;
+  static const uint64_t static_value2 = 0x52e78631c0c6b702ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::cartographer_ros_msgs::WriteStateRequest_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/WriteStateRequest";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::WriteStateRequest_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::cartographer_ros_msgs::WriteStateRequest_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+\n\
+string filename\n\
+bool include_unfinished_submaps\n\
+";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::WriteStateRequest_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::cartographer_ros_msgs::WriteStateRequest_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.filename);
+      stream.next(m.include_unfinished_submaps);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct WriteStateRequest_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::cartographer_ros_msgs::WriteStateRequest_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::cartographer_ros_msgs::WriteStateRequest_<ContainerAllocator>& v)
+  {
+    s << indent << "filename: ";
+    Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + "  ", v.filename);
+    s << indent << "include_unfinished_submaps: ";
+    Printer<uint8_t>::stream(s, indent + "  ", v.include_unfinished_submaps);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // CARTOGRAPHER_ROS_MSGS_MESSAGE_WRITESTATEREQUEST_H

devel/include/cartographer_ros_msgs/WriteStateResponse.h

@@ -0,0 +1,210 @@
+// Generated by gencpp from file cartographer_ros_msgs/WriteStateResponse.msg
+// DO NOT EDIT!
+
+
+#ifndef CARTOGRAPHER_ROS_MSGS_MESSAGE_WRITESTATERESPONSE_H
+#define CARTOGRAPHER_ROS_MSGS_MESSAGE_WRITESTATERESPONSE_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <ros/types.h>
+#include <ros/serialization.h>
+#include <ros/builtin_message_traits.h>
+#include <ros/message_operations.h>
+
+#include <cartographer_ros_msgs/StatusResponse.h>
+
+namespace cartographer_ros_msgs
+{
+template <class ContainerAllocator>
+struct WriteStateResponse_
+{
+  typedef WriteStateResponse_<ContainerAllocator> Type;
+
+  WriteStateResponse_()
+    : status()  {
+    }
+  WriteStateResponse_(const ContainerAllocator& _alloc)
+    : status(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator>  _status_type;
+  _status_type status;
+
+
+
+
+
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::WriteStateResponse_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::cartographer_ros_msgs::WriteStateResponse_<ContainerAllocator> const> ConstPtr;
+
+}; // struct WriteStateResponse_
+
+typedef ::cartographer_ros_msgs::WriteStateResponse_<std::allocator<void> > WriteStateResponse;
+
+typedef boost::shared_ptr< ::cartographer_ros_msgs::WriteStateResponse > WriteStateResponsePtr;
+typedef boost::shared_ptr< ::cartographer_ros_msgs::WriteStateResponse const> WriteStateResponseConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::cartographer_ros_msgs::WriteStateResponse_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::cartographer_ros_msgs::WriteStateResponse_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace cartographer_ros_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
+// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'cartographer_ros_msgs': ['/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_ros_msgs/msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
+
+
+
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::WriteStateResponse_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::cartographer_ros_msgs::WriteStateResponse_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::WriteStateResponse_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::cartographer_ros_msgs::WriteStateResponse_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::WriteStateResponse_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::cartographer_ros_msgs::WriteStateResponse_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::cartographer_ros_msgs::WriteStateResponse_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "4e6ca4e44081fa06b258fa12804ea7cb";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::WriteStateResponse_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x4e6ca4e44081fa06ULL;
+  static const uint64_t static_value2 = 0xb258fa12804ea7cbULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::cartographer_ros_msgs::WriteStateResponse_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/WriteStateResponse";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::WriteStateResponse_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::cartographer_ros_msgs::WriteStateResponse_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "cartographer_ros_msgs/StatusResponse status\n\
+\n\
+\n\
+================================================================================\n\
+MSG: cartographer_ros_msgs/StatusResponse\n\
+# Copyright 2018 The Cartographer Authors\n\
+#\n\
+# Licensed under the Apache License, Version 2.0 (the \"License\");\n\
+# you may not use this file except in compliance with the License.\n\
+# You may obtain a copy of the License at\n\
+#\n\
+#      http://www.apache.org/licenses/LICENSE-2.0\n\
+#\n\
+# Unless required by applicable law or agreed to in writing, software\n\
+# distributed under the License is distributed on an \"AS IS\" BASIS,\n\
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+# See the License for the specific language governing permissions and\n\
+# limitations under the License.\n\
+\n\
+# A common message type to indicate the outcome of a service call.\n\
+uint8 code\n\
+string message\n\
+";
+  }
+
+  static const char* value(const ::cartographer_ros_msgs::WriteStateResponse_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::cartographer_ros_msgs::WriteStateResponse_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.status);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct WriteStateResponse_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::cartographer_ros_msgs::WriteStateResponse_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::cartographer_ros_msgs::WriteStateResponse_<ContainerAllocator>& v)
+  {
+    s << indent << "status: ";
+    s << std::endl;
+    Printer< ::cartographer_ros_msgs::StatusResponse_<ContainerAllocator> >::stream(s, indent + "  ", v.status);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // CARTOGRAPHER_ROS_MSGS_MESSAGE_WRITESTATERESPONSE_H

devel/include/rbx1_nav/CalibrateAngularConfig.h

@@ -0,0 +1,531 @@
+//#line 2 "/opt/ros/melodic/share/dynamic_reconfigure/cmake/../templates/ConfigType.h.template"
+// *********************************************************
+//
+// File autogenerated for the rbx1_nav package
+// by the dynamic_reconfigure package.
+// Please do not edit.
+//
+// ********************************************************/
+
+#ifndef __rbx1_nav__CALIBRATEANGULARCONFIG_H__
+#define __rbx1_nav__CALIBRATEANGULARCONFIG_H__
+
+#include <dynamic_reconfigure/config_tools.h>
+#include <limits>
+#include <ros/node_handle.h>
+#include <dynamic_reconfigure/ConfigDescription.h>
+#include <dynamic_reconfigure/ParamDescription.h>
+#include <dynamic_reconfigure/Group.h>
+#include <dynamic_reconfigure/config_init_mutex.h>
+#include <boost/any.hpp>
+
+namespace rbx1_nav
+{
+  class CalibrateAngularConfigStatics;
+
+  class CalibrateAngularConfig
+  {
+  public:
+    class AbstractParamDescription : public dynamic_reconfigure::ParamDescription
+    {
+    public:
+      AbstractParamDescription(std::string n, std::string t, uint32_t l,
+          std::string d, std::string e)
+      {
+        name = n;
+        type = t;
+        level = l;
+        description = d;
+        edit_method = e;
+      }
+
+      virtual void clamp(CalibrateAngularConfig &config, const CalibrateAngularConfig &max, const CalibrateAngularConfig &min) const = 0;
+      virtual void calcLevel(uint32_t &level, const CalibrateAngularConfig &config1, const CalibrateAngularConfig &config2) const = 0;
+      virtual void fromServer(const ros::NodeHandle &nh, CalibrateAngularConfig &config) const = 0;
+      virtual void toServer(const ros::NodeHandle &nh, const CalibrateAngularConfig &config) const = 0;
+      virtual bool fromMessage(const dynamic_reconfigure::Config &msg, CalibrateAngularConfig &config) const = 0;
+      virtual void toMessage(dynamic_reconfigure::Config &msg, const CalibrateAngularConfig &config) const = 0;
+      virtual void getValue(const CalibrateAngularConfig &config, boost::any &val) const = 0;
+    };
+
+    typedef boost::shared_ptr<AbstractParamDescription> AbstractParamDescriptionPtr;
+    typedef boost::shared_ptr<const AbstractParamDescription> AbstractParamDescriptionConstPtr;
+
+    template <class T>
+    class ParamDescription : public AbstractParamDescription
+    {
+    public:
+      ParamDescription(std::string a_name, std::string a_type, uint32_t a_level,
+          std::string a_description, std::string a_edit_method, T CalibrateAngularConfig::* a_f) :
+        AbstractParamDescription(a_name, a_type, a_level, a_description, a_edit_method),
+        field(a_f)
+      {}
+
+      T (CalibrateAngularConfig::* field);
+
+      virtual void clamp(CalibrateAngularConfig &config, const CalibrateAngularConfig &max, const CalibrateAngularConfig &min) const
+      {
+        if (config.*field > max.*field)
+          config.*field = max.*field;
+
+        if (config.*field < min.*field)
+          config.*field = min.*field;
+      }
+
+      virtual void calcLevel(uint32_t &comb_level, const CalibrateAngularConfig &config1, const CalibrateAngularConfig &config2) const
+      {
+        if (config1.*field != config2.*field)
+          comb_level |= level;
+      }
+
+      virtual void fromServer(const ros::NodeHandle &nh, CalibrateAngularConfig &config) const
+      {
+        nh.getParam(name, config.*field);
+      }
+
+      virtual void toServer(const ros::NodeHandle &nh, const CalibrateAngularConfig &config) const
+      {
+        nh.setParam(name, config.*field);
+      }
+
+      virtual bool fromMessage(const dynamic_reconfigure::Config &msg, CalibrateAngularConfig &config) const
+      {
+        return dynamic_reconfigure::ConfigTools::getParameter(msg, name, config.*field);
+      }
+
+      virtual void toMessage(dynamic_reconfigure::Config &msg, const CalibrateAngularConfig &config) const
+      {
+        dynamic_reconfigure::ConfigTools::appendParameter(msg, name, config.*field);
+      }
+
+      virtual void getValue(const CalibrateAngularConfig &config, boost::any &val) const
+      {
+        val = config.*field;
+      }
+    };
+
+    class AbstractGroupDescription : public dynamic_reconfigure::Group
+    {
+      public:
+      AbstractGroupDescription(std::string n, std::string t, int p, int i, bool s)
+      {
+        name = n;
+        type = t;
+        parent = p;
+        state = s;
+        id = i;
+      }
+
+      std::vector<AbstractParamDescriptionConstPtr> abstract_parameters;
+      bool state;
+
+      virtual void toMessage(dynamic_reconfigure::Config &msg, const boost::any &config) const = 0;
+      virtual bool fromMessage(const dynamic_reconfigure::Config &msg, boost::any &config) const =0;
+      virtual void updateParams(boost::any &cfg, CalibrateAngularConfig &top) const= 0;
+      virtual void setInitialState(boost::any &cfg) const = 0;
+
+
+      void convertParams()
+      {
+        for(std::vector<AbstractParamDescriptionConstPtr>::const_iterator i = abstract_parameters.begin(); i != abstract_parameters.end(); ++i)
+        {
+          parameters.push_back(dynamic_reconfigure::ParamDescription(**i));
+        }
+      }
+    };
+
+    typedef boost::shared_ptr<AbstractGroupDescription> AbstractGroupDescriptionPtr;
+    typedef boost::shared_ptr<const AbstractGroupDescription> AbstractGroupDescriptionConstPtr;
+
+    template<class T, class PT>
+    class GroupDescription : public AbstractGroupDescription
+    {
+    public:
+      GroupDescription(std::string a_name, std::string a_type, int a_parent, int a_id, bool a_s, T PT::* a_f) : AbstractGroupDescription(a_name, a_type, a_parent, a_id, a_s), field(a_f)
+      {
+      }
+
+      GroupDescription(const GroupDescription<T, PT>& g): AbstractGroupDescription(g.name, g.type, g.parent, g.id, g.state), field(g.field), groups(g.groups)
+      {
+        parameters = g.parameters;
+        abstract_parameters = g.abstract_parameters;
+      }
+
+      virtual bool fromMessage(const dynamic_reconfigure::Config &msg, boost::any &cfg) const
+      {
+        PT* config = boost::any_cast<PT*>(cfg);
+        if(!dynamic_reconfigure::ConfigTools::getGroupState(msg, name, (*config).*field))
+          return false;
+
+        for(std::vector<AbstractGroupDescriptionConstPtr>::const_iterator i = groups.begin(); i != groups.end(); ++i)
+        {
+          boost::any n = &((*config).*field);
+          if(!(*i)->fromMessage(msg, n))
+            return false;
+        }
+
+        return true;
+      }
+
+      virtual void setInitialState(boost::any &cfg) const
+      {
+        PT* config = boost::any_cast<PT*>(cfg);
+        T* group = &((*config).*field);
+        group->state = state;
+
+        for(std::vector<AbstractGroupDescriptionConstPtr>::const_iterator i = groups.begin(); i != groups.end(); ++i)
+        {
+          boost::any n = boost::any(&((*config).*field));
+          (*i)->setInitialState(n);
+        }
+
+      }
+
+      virtual void updateParams(boost::any &cfg, CalibrateAngularConfig &top) const
+      {
+        PT* config = boost::any_cast<PT*>(cfg);
+
+        T* f = &((*config).*field);
+        f->setParams(top, abstract_parameters);
+
+        for(std::vector<AbstractGroupDescriptionConstPtr>::const_iterator i = groups.begin(); i != groups.end(); ++i)
+        {
+          boost::any n = &((*config).*field);
+          (*i)->updateParams(n, top);
+        }
+      }
+
+      virtual void toMessage(dynamic_reconfigure::Config &msg, const boost::any &cfg) const
+      {
+        const PT config = boost::any_cast<PT>(cfg);
+        dynamic_reconfigure::ConfigTools::appendGroup<T>(msg, name, id, parent, config.*field);
+
+        for(std::vector<AbstractGroupDescriptionConstPtr>::const_iterator i = groups.begin(); i != groups.end(); ++i)
+        {
+          (*i)->toMessage(msg, config.*field);
+        }
+      }
+
+      T (PT::* field);
+      std::vector<CalibrateAngularConfig::AbstractGroupDescriptionConstPtr> groups;
+    };
+
+class DEFAULT
+{
+  public:
+    DEFAULT()
+    {
+      state = true;
+      name = "Default";
+    }
+
+    void setParams(CalibrateAngularConfig &config, const std::vector<AbstractParamDescriptionConstPtr> params)
+    {
+      for (std::vector<AbstractParamDescriptionConstPtr>::const_iterator _i = params.begin(); _i != params.end(); ++_i)
+      {
+        boost::any val;
+        (*_i)->getValue(config, val);
+
+        if("test_angle"==(*_i)->name){test_angle = boost::any_cast<double>(val);}
+        if("speed"==(*_i)->name){speed = boost::any_cast<double>(val);}
+        if("tolerance"==(*_i)->name){tolerance = boost::any_cast<double>(val);}
+        if("odom_angular_scale_correction"==(*_i)->name){odom_angular_scale_correction = boost::any_cast<double>(val);}
+        if("start_test"==(*_i)->name){start_test = boost::any_cast<bool>(val);}
+      }
+    }
+
+    double test_angle;
+double speed;
+double tolerance;
+double odom_angular_scale_correction;
+bool start_test;
+
+    bool state;
+    std::string name;
+
+    
+}groups;
+
+
+
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      double test_angle;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      double speed;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      double tolerance;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      double odom_angular_scale_correction;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      bool start_test;
+//#line 218 "/opt/ros/melodic/share/dynamic_reconfigure/cmake/../templates/ConfigType.h.template"
+
+    bool __fromMessage__(dynamic_reconfigure::Config &msg)
+    {
+      const std::vector<AbstractParamDescriptionConstPtr> &__param_descriptions__ = __getParamDescriptions__();
+      const std::vector<AbstractGroupDescriptionConstPtr> &__group_descriptions__ = __getGroupDescriptions__();
+
+      int count = 0;
+      for (std::vector<AbstractParamDescriptionConstPtr>::const_iterator i = __param_descriptions__.begin(); i != __param_descriptions__.end(); ++i)
+        if ((*i)->fromMessage(msg, *this))
+          count++;
+
+      for (std::vector<AbstractGroupDescriptionConstPtr>::const_iterator i = __group_descriptions__.begin(); i != __group_descriptions__.end(); i ++)
+      {
+        if ((*i)->id == 0)
+        {
+          boost::any n = boost::any(this);
+          (*i)->updateParams(n, *this);
+          (*i)->fromMessage(msg, n);
+        }
+      }
+
+      if (count != dynamic_reconfigure::ConfigTools::size(msg))
+      {
+        ROS_ERROR("CalibrateAngularConfig::__fromMessage__ called with an unexpected parameter.");
+        ROS_ERROR("Booleans:");
+        for (unsigned int i = 0; i < msg.bools.size(); i++)
+          ROS_ERROR("  %s", msg.bools[i].name.c_str());
+        ROS_ERROR("Integers:");
+        for (unsigned int i = 0; i < msg.ints.size(); i++)
+          ROS_ERROR("  %s", msg.ints[i].name.c_str());
+        ROS_ERROR("Doubles:");
+        for (unsigned int i = 0; i < msg.doubles.size(); i++)
+          ROS_ERROR("  %s", msg.doubles[i].name.c_str());
+        ROS_ERROR("Strings:");
+        for (unsigned int i = 0; i < msg.strs.size(); i++)
+          ROS_ERROR("  %s", msg.strs[i].name.c_str());
+        // @todo Check that there are no duplicates. Make this error more
+        // explicit.
+        return false;
+      }
+      return true;
+    }
+
+    // This version of __toMessage__ is used during initialization of
+    // statics when __getParamDescriptions__ can't be called yet.
+    void __toMessage__(dynamic_reconfigure::Config &msg, const std::vector<AbstractParamDescriptionConstPtr> &__param_descriptions__, const std::vector<AbstractGroupDescriptionConstPtr> &__group_descriptions__) const
+    {
+      dynamic_reconfigure::ConfigTools::clear(msg);
+      for (std::vector<AbstractParamDescriptionConstPtr>::const_iterator i = __param_descriptions__.begin(); i != __param_descriptions__.end(); ++i)
+        (*i)->toMessage(msg, *this);
+
+      for (std::vector<AbstractGroupDescriptionConstPtr>::const_iterator i = __group_descriptions__.begin(); i != __group_descriptions__.end(); ++i)
+      {
+        if((*i)->id == 0)
+        {
+          (*i)->toMessage(msg, *this);
+        }
+      }
+    }
+
+    void __toMessage__(dynamic_reconfigure::Config &msg) const
+    {
+      const std::vector<AbstractParamDescriptionConstPtr> &__param_descriptions__ = __getParamDescriptions__();
+      const std::vector<AbstractGroupDescriptionConstPtr> &__group_descriptions__ = __getGroupDescriptions__();
+      __toMessage__(msg, __param_descriptions__, __group_descriptions__);
+    }
+
+    void __toServer__(const ros::NodeHandle &nh) const
+    {
+      const std::vector<AbstractParamDescriptionConstPtr> &__param_descriptions__ = __getParamDescriptions__();
+      for (std::vector<AbstractParamDescriptionConstPtr>::const_iterator i = __param_descriptions__.begin(); i != __param_descriptions__.end(); ++i)
+        (*i)->toServer(nh, *this);
+    }
+
+    void __fromServer__(const ros::NodeHandle &nh)
+    {
+      static bool setup=false;
+
+      const std::vector<AbstractParamDescriptionConstPtr> &__param_descriptions__ = __getParamDescriptions__();
+      for (std::vector<AbstractParamDescriptionConstPtr>::const_iterator i = __param_descriptions__.begin(); i != __param_descriptions__.end(); ++i)
+        (*i)->fromServer(nh, *this);
+
+      const std::vector<AbstractGroupDescriptionConstPtr> &__group_descriptions__ = __getGroupDescriptions__();
+      for (std::vector<AbstractGroupDescriptionConstPtr>::const_iterator i = __group_descriptions__.begin(); i != __group_descriptions__.end(); i++){
+        if (!setup && (*i)->id == 0) {
+          setup = true;
+          boost::any n = boost::any(this);
+          (*i)->setInitialState(n);
+        }
+      }
+    }
+
+    void __clamp__()
+    {
+      const std::vector<AbstractParamDescriptionConstPtr> &__param_descriptions__ = __getParamDescriptions__();
+      const CalibrateAngularConfig &__max__ = __getMax__();
+      const CalibrateAngularConfig &__min__ = __getMin__();
+      for (std::vector<AbstractParamDescriptionConstPtr>::const_iterator i = __param_descriptions__.begin(); i != __param_descriptions__.end(); ++i)
+        (*i)->clamp(*this, __max__, __min__);
+    }
+
+    uint32_t __level__(const CalibrateAngularConfig &config) const
+    {
+      const std::vector<AbstractParamDescriptionConstPtr> &__param_descriptions__ = __getParamDescriptions__();
+      uint32_t level = 0;
+      for (std::vector<AbstractParamDescriptionConstPtr>::const_iterator i = __param_descriptions__.begin(); i != __param_descriptions__.end(); ++i)
+        (*i)->calcLevel(level, config, *this);
+      return level;
+    }
+
+    static const dynamic_reconfigure::ConfigDescription &__getDescriptionMessage__();
+    static const CalibrateAngularConfig &__getDefault__();
+    static const CalibrateAngularConfig &__getMax__();
+    static const CalibrateAngularConfig &__getMin__();
+    static const std::vector<AbstractParamDescriptionConstPtr> &__getParamDescriptions__();
+    static const std::vector<AbstractGroupDescriptionConstPtr> &__getGroupDescriptions__();
+
+  private:
+    static const CalibrateAngularConfigStatics *__get_statics__();
+  };
+
+  template <> // Max and min are ignored for strings.
+  inline void CalibrateAngularConfig::ParamDescription<std::string>::clamp(CalibrateAngularConfig &config, const CalibrateAngularConfig &max, const CalibrateAngularConfig &min) const
+  {
+    (void) config;
+    (void) min;
+    (void) max;
+    return;
+  }
+
+  class CalibrateAngularConfigStatics
+  {
+    friend class CalibrateAngularConfig;
+
+    CalibrateAngularConfigStatics()
+    {
+CalibrateAngularConfig::GroupDescription<CalibrateAngularConfig::DEFAULT, CalibrateAngularConfig> Default("Default", "", 0, 0, true, &CalibrateAngularConfig::groups);
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __min__.test_angle = 0.0;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __max__.test_angle = 360.0;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __default__.test_angle = 360.0;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      Default.abstract_parameters.push_back(CalibrateAngularConfig::AbstractParamDescriptionConstPtr(new CalibrateAngularConfig::ParamDescription<double>("test_angle", "double", 0, "Test Angle", "", &CalibrateAngularConfig::test_angle)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __param_descriptions__.push_back(CalibrateAngularConfig::AbstractParamDescriptionConstPtr(new CalibrateAngularConfig::ParamDescription<double>("test_angle", "double", 0, "Test Angle", "", &CalibrateAngularConfig::test_angle)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __min__.speed = -1.5;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __max__.speed = 1.5;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __default__.speed = 0.5;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      Default.abstract_parameters.push_back(CalibrateAngularConfig::AbstractParamDescriptionConstPtr(new CalibrateAngularConfig::ParamDescription<double>("speed", "double", 0, "Angular speed in radians per second", "", &CalibrateAngularConfig::speed)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __param_descriptions__.push_back(CalibrateAngularConfig::AbstractParamDescriptionConstPtr(new CalibrateAngularConfig::ParamDescription<double>("speed", "double", 0, "Angular speed in radians per second", "", &CalibrateAngularConfig::speed)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __min__.tolerance = 1.0;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __max__.tolerance = 10.0;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __default__.tolerance = 1.0;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      Default.abstract_parameters.push_back(CalibrateAngularConfig::AbstractParamDescriptionConstPtr(new CalibrateAngularConfig::ParamDescription<double>("tolerance", "double", 0, "Error tolerance to goal angle in degrees", "", &CalibrateAngularConfig::tolerance)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __param_descriptions__.push_back(CalibrateAngularConfig::AbstractParamDescriptionConstPtr(new CalibrateAngularConfig::ParamDescription<double>("tolerance", "double", 0, "Error tolerance to goal angle in degrees", "", &CalibrateAngularConfig::tolerance)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __min__.odom_angular_scale_correction = 0.0;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __max__.odom_angular_scale_correction = 3.0;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __default__.odom_angular_scale_correction = 1.0;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      Default.abstract_parameters.push_back(CalibrateAngularConfig::AbstractParamDescriptionConstPtr(new CalibrateAngularConfig::ParamDescription<double>("odom_angular_scale_correction", "double", 0, "Angular correction factor", "", &CalibrateAngularConfig::odom_angular_scale_correction)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __param_descriptions__.push_back(CalibrateAngularConfig::AbstractParamDescriptionConstPtr(new CalibrateAngularConfig::ParamDescription<double>("odom_angular_scale_correction", "double", 0, "Angular correction factor", "", &CalibrateAngularConfig::odom_angular_scale_correction)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __min__.start_test = 0;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __max__.start_test = 1;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __default__.start_test = 0;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      Default.abstract_parameters.push_back(CalibrateAngularConfig::AbstractParamDescriptionConstPtr(new CalibrateAngularConfig::ParamDescription<bool>("start_test", "bool", 0, "Check to start the test", "", &CalibrateAngularConfig::start_test)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __param_descriptions__.push_back(CalibrateAngularConfig::AbstractParamDescriptionConstPtr(new CalibrateAngularConfig::ParamDescription<bool>("start_test", "bool", 0, "Check to start the test", "", &CalibrateAngularConfig::start_test)));
+//#line 245 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      Default.convertParams();
+//#line 245 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __group_descriptions__.push_back(CalibrateAngularConfig::AbstractGroupDescriptionConstPtr(new CalibrateAngularConfig::GroupDescription<CalibrateAngularConfig::DEFAULT, CalibrateAngularConfig>(Default)));
+//#line 356 "/opt/ros/melodic/share/dynamic_reconfigure/cmake/../templates/ConfigType.h.template"
+
+      for (std::vector<CalibrateAngularConfig::AbstractGroupDescriptionConstPtr>::const_iterator i = __group_descriptions__.begin(); i != __group_descriptions__.end(); ++i)
+      {
+        __description_message__.groups.push_back(**i);
+      }
+      __max__.__toMessage__(__description_message__.max, __param_descriptions__, __group_descriptions__);
+      __min__.__toMessage__(__description_message__.min, __param_descriptions__, __group_descriptions__);
+      __default__.__toMessage__(__description_message__.dflt, __param_descriptions__, __group_descriptions__);
+    }
+    std::vector<CalibrateAngularConfig::AbstractParamDescriptionConstPtr> __param_descriptions__;
+    std::vector<CalibrateAngularConfig::AbstractGroupDescriptionConstPtr> __group_descriptions__;
+    CalibrateAngularConfig __max__;
+    CalibrateAngularConfig __min__;
+    CalibrateAngularConfig __default__;
+    dynamic_reconfigure::ConfigDescription __description_message__;
+
+    static const CalibrateAngularConfigStatics *get_instance()
+    {
+      // Split this off in a separate function because I know that
+      // instance will get initialized the first time get_instance is
+      // called, and I am guaranteeing that get_instance gets called at
+      // most once.
+      static CalibrateAngularConfigStatics instance;
+      return &instance;
+    }
+  };
+
+  inline const dynamic_reconfigure::ConfigDescription &CalibrateAngularConfig::__getDescriptionMessage__()
+  {
+    return __get_statics__()->__description_message__;
+  }
+
+  inline const CalibrateAngularConfig &CalibrateAngularConfig::__getDefault__()
+  {
+    return __get_statics__()->__default__;
+  }
+
+  inline const CalibrateAngularConfig &CalibrateAngularConfig::__getMax__()
+  {
+    return __get_statics__()->__max__;
+  }
+
+  inline const CalibrateAngularConfig &CalibrateAngularConfig::__getMin__()
+  {
+    return __get_statics__()->__min__;
+  }
+
+  inline const std::vector<CalibrateAngularConfig::AbstractParamDescriptionConstPtr> &CalibrateAngularConfig::__getParamDescriptions__()
+  {
+    return __get_statics__()->__param_descriptions__;
+  }
+
+  inline const std::vector<CalibrateAngularConfig::AbstractGroupDescriptionConstPtr> &CalibrateAngularConfig::__getGroupDescriptions__()
+  {
+    return __get_statics__()->__group_descriptions__;
+  }
+
+  inline const CalibrateAngularConfigStatics *CalibrateAngularConfig::__get_statics__()
+  {
+    const static CalibrateAngularConfigStatics *statics;
+
+    if (statics) // Common case
+      return statics;
+
+    boost::mutex::scoped_lock lock(dynamic_reconfigure::__init_mutex__);
+
+    if (statics) // In case we lost a race.
+      return statics;
+
+    statics = CalibrateAngularConfigStatics::get_instance();
+
+    return statics;
+  }
+
+
+}
+
+#endif // __CALIBRATEANGULARRECONFIGURATOR_H__

devel/include/rbx1_nav/CalibrateLinearConfig.h

@@ -0,0 +1,531 @@
+//#line 2 "/opt/ros/melodic/share/dynamic_reconfigure/cmake/../templates/ConfigType.h.template"
+// *********************************************************
+//
+// File autogenerated for the rbx1_nav package
+// by the dynamic_reconfigure package.
+// Please do not edit.
+//
+// ********************************************************/
+
+#ifndef __rbx1_nav__CALIBRATELINEARCONFIG_H__
+#define __rbx1_nav__CALIBRATELINEARCONFIG_H__
+
+#include <dynamic_reconfigure/config_tools.h>
+#include <limits>
+#include <ros/node_handle.h>
+#include <dynamic_reconfigure/ConfigDescription.h>
+#include <dynamic_reconfigure/ParamDescription.h>
+#include <dynamic_reconfigure/Group.h>
+#include <dynamic_reconfigure/config_init_mutex.h>
+#include <boost/any.hpp>
+
+namespace rbx1_nav
+{
+  class CalibrateLinearConfigStatics;
+
+  class CalibrateLinearConfig
+  {
+  public:
+    class AbstractParamDescription : public dynamic_reconfigure::ParamDescription
+    {
+    public:
+      AbstractParamDescription(std::string n, std::string t, uint32_t l,
+          std::string d, std::string e)
+      {
+        name = n;
+        type = t;
+        level = l;
+        description = d;
+        edit_method = e;
+      }
+
+      virtual void clamp(CalibrateLinearConfig &config, const CalibrateLinearConfig &max, const CalibrateLinearConfig &min) const = 0;
+      virtual void calcLevel(uint32_t &level, const CalibrateLinearConfig &config1, const CalibrateLinearConfig &config2) const = 0;
+      virtual void fromServer(const ros::NodeHandle &nh, CalibrateLinearConfig &config) const = 0;
+      virtual void toServer(const ros::NodeHandle &nh, const CalibrateLinearConfig &config) const = 0;
+      virtual bool fromMessage(const dynamic_reconfigure::Config &msg, CalibrateLinearConfig &config) const = 0;
+      virtual void toMessage(dynamic_reconfigure::Config &msg, const CalibrateLinearConfig &config) const = 0;
+      virtual void getValue(const CalibrateLinearConfig &config, boost::any &val) const = 0;
+    };
+
+    typedef boost::shared_ptr<AbstractParamDescription> AbstractParamDescriptionPtr;
+    typedef boost::shared_ptr<const AbstractParamDescription> AbstractParamDescriptionConstPtr;
+
+    template <class T>
+    class ParamDescription : public AbstractParamDescription
+    {
+    public:
+      ParamDescription(std::string a_name, std::string a_type, uint32_t a_level,
+          std::string a_description, std::string a_edit_method, T CalibrateLinearConfig::* a_f) :
+        AbstractParamDescription(a_name, a_type, a_level, a_description, a_edit_method),
+        field(a_f)
+      {}
+
+      T (CalibrateLinearConfig::* field);
+
+      virtual void clamp(CalibrateLinearConfig &config, const CalibrateLinearConfig &max, const CalibrateLinearConfig &min) const
+      {
+        if (config.*field > max.*field)
+          config.*field = max.*field;
+
+        if (config.*field < min.*field)
+          config.*field = min.*field;
+      }
+
+      virtual void calcLevel(uint32_t &comb_level, const CalibrateLinearConfig &config1, const CalibrateLinearConfig &config2) const
+      {
+        if (config1.*field != config2.*field)
+          comb_level |= level;
+      }
+
+      virtual void fromServer(const ros::NodeHandle &nh, CalibrateLinearConfig &config) const
+      {
+        nh.getParam(name, config.*field);
+      }
+
+      virtual void toServer(const ros::NodeHandle &nh, const CalibrateLinearConfig &config) const
+      {
+        nh.setParam(name, config.*field);
+      }
+
+      virtual bool fromMessage(const dynamic_reconfigure::Config &msg, CalibrateLinearConfig &config) const
+      {
+        return dynamic_reconfigure::ConfigTools::getParameter(msg, name, config.*field);
+      }
+
+      virtual void toMessage(dynamic_reconfigure::Config &msg, const CalibrateLinearConfig &config) const
+      {
+        dynamic_reconfigure::ConfigTools::appendParameter(msg, name, config.*field);
+      }
+
+      virtual void getValue(const CalibrateLinearConfig &config, boost::any &val) const
+      {
+        val = config.*field;
+      }
+    };
+
+    class AbstractGroupDescription : public dynamic_reconfigure::Group
+    {
+      public:
+      AbstractGroupDescription(std::string n, std::string t, int p, int i, bool s)
+      {
+        name = n;
+        type = t;
+        parent = p;
+        state = s;
+        id = i;
+      }
+
+      std::vector<AbstractParamDescriptionConstPtr> abstract_parameters;
+      bool state;
+
+      virtual void toMessage(dynamic_reconfigure::Config &msg, const boost::any &config) const = 0;
+      virtual bool fromMessage(const dynamic_reconfigure::Config &msg, boost::any &config) const =0;
+      virtual void updateParams(boost::any &cfg, CalibrateLinearConfig &top) const= 0;
+      virtual void setInitialState(boost::any &cfg) const = 0;
+
+
+      void convertParams()
+      {
+        for(std::vector<AbstractParamDescriptionConstPtr>::const_iterator i = abstract_parameters.begin(); i != abstract_parameters.end(); ++i)
+        {
+          parameters.push_back(dynamic_reconfigure::ParamDescription(**i));
+        }
+      }
+    };
+
+    typedef boost::shared_ptr<AbstractGroupDescription> AbstractGroupDescriptionPtr;
+    typedef boost::shared_ptr<const AbstractGroupDescription> AbstractGroupDescriptionConstPtr;
+
+    template<class T, class PT>
+    class GroupDescription : public AbstractGroupDescription
+    {
+    public:
+      GroupDescription(std::string a_name, std::string a_type, int a_parent, int a_id, bool a_s, T PT::* a_f) : AbstractGroupDescription(a_name, a_type, a_parent, a_id, a_s), field(a_f)
+      {
+      }
+
+      GroupDescription(const GroupDescription<T, PT>& g): AbstractGroupDescription(g.name, g.type, g.parent, g.id, g.state), field(g.field), groups(g.groups)
+      {
+        parameters = g.parameters;
+        abstract_parameters = g.abstract_parameters;
+      }
+
+      virtual bool fromMessage(const dynamic_reconfigure::Config &msg, boost::any &cfg) const
+      {
+        PT* config = boost::any_cast<PT*>(cfg);
+        if(!dynamic_reconfigure::ConfigTools::getGroupState(msg, name, (*config).*field))
+          return false;
+
+        for(std::vector<AbstractGroupDescriptionConstPtr>::const_iterator i = groups.begin(); i != groups.end(); ++i)
+        {
+          boost::any n = &((*config).*field);
+          if(!(*i)->fromMessage(msg, n))
+            return false;
+        }
+
+        return true;
+      }
+
+      virtual void setInitialState(boost::any &cfg) const
+      {
+        PT* config = boost::any_cast<PT*>(cfg);
+        T* group = &((*config).*field);
+        group->state = state;
+
+        for(std::vector<AbstractGroupDescriptionConstPtr>::const_iterator i = groups.begin(); i != groups.end(); ++i)
+        {
+          boost::any n = boost::any(&((*config).*field));
+          (*i)->setInitialState(n);
+        }
+
+      }
+
+      virtual void updateParams(boost::any &cfg, CalibrateLinearConfig &top) const
+      {
+        PT* config = boost::any_cast<PT*>(cfg);
+
+        T* f = &((*config).*field);
+        f->setParams(top, abstract_parameters);
+
+        for(std::vector<AbstractGroupDescriptionConstPtr>::const_iterator i = groups.begin(); i != groups.end(); ++i)
+        {
+          boost::any n = &((*config).*field);
+          (*i)->updateParams(n, top);
+        }
+      }
+
+      virtual void toMessage(dynamic_reconfigure::Config &msg, const boost::any &cfg) const
+      {
+        const PT config = boost::any_cast<PT>(cfg);
+        dynamic_reconfigure::ConfigTools::appendGroup<T>(msg, name, id, parent, config.*field);
+
+        for(std::vector<AbstractGroupDescriptionConstPtr>::const_iterator i = groups.begin(); i != groups.end(); ++i)
+        {
+          (*i)->toMessage(msg, config.*field);
+        }
+      }
+
+      T (PT::* field);
+      std::vector<CalibrateLinearConfig::AbstractGroupDescriptionConstPtr> groups;
+    };
+
+class DEFAULT
+{
+  public:
+    DEFAULT()
+    {
+      state = true;
+      name = "Default";
+    }
+
+    void setParams(CalibrateLinearConfig &config, const std::vector<AbstractParamDescriptionConstPtr> params)
+    {
+      for (std::vector<AbstractParamDescriptionConstPtr>::const_iterator _i = params.begin(); _i != params.end(); ++_i)
+      {
+        boost::any val;
+        (*_i)->getValue(config, val);
+
+        if("test_distance"==(*_i)->name){test_distance = boost::any_cast<double>(val);}
+        if("speed"==(*_i)->name){speed = boost::any_cast<double>(val);}
+        if("tolerance"==(*_i)->name){tolerance = boost::any_cast<double>(val);}
+        if("odom_linear_scale_correction"==(*_i)->name){odom_linear_scale_correction = boost::any_cast<double>(val);}
+        if("start_test"==(*_i)->name){start_test = boost::any_cast<bool>(val);}
+      }
+    }
+
+    double test_distance;
+double speed;
+double tolerance;
+double odom_linear_scale_correction;
+bool start_test;
+
+    bool state;
+    std::string name;
+
+    
+}groups;
+
+
+
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      double test_distance;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      double speed;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      double tolerance;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      double odom_linear_scale_correction;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      bool start_test;
+//#line 218 "/opt/ros/melodic/share/dynamic_reconfigure/cmake/../templates/ConfigType.h.template"
+
+    bool __fromMessage__(dynamic_reconfigure::Config &msg)
+    {
+      const std::vector<AbstractParamDescriptionConstPtr> &__param_descriptions__ = __getParamDescriptions__();
+      const std::vector<AbstractGroupDescriptionConstPtr> &__group_descriptions__ = __getGroupDescriptions__();
+
+      int count = 0;
+      for (std::vector<AbstractParamDescriptionConstPtr>::const_iterator i = __param_descriptions__.begin(); i != __param_descriptions__.end(); ++i)
+        if ((*i)->fromMessage(msg, *this))
+          count++;
+
+      for (std::vector<AbstractGroupDescriptionConstPtr>::const_iterator i = __group_descriptions__.begin(); i != __group_descriptions__.end(); i ++)
+      {
+        if ((*i)->id == 0)
+        {
+          boost::any n = boost::any(this);
+          (*i)->updateParams(n, *this);
+          (*i)->fromMessage(msg, n);
+        }
+      }
+
+      if (count != dynamic_reconfigure::ConfigTools::size(msg))
+      {
+        ROS_ERROR("CalibrateLinearConfig::__fromMessage__ called with an unexpected parameter.");
+        ROS_ERROR("Booleans:");
+        for (unsigned int i = 0; i < msg.bools.size(); i++)
+          ROS_ERROR("  %s", msg.bools[i].name.c_str());
+        ROS_ERROR("Integers:");
+        for (unsigned int i = 0; i < msg.ints.size(); i++)
+          ROS_ERROR("  %s", msg.ints[i].name.c_str());
+        ROS_ERROR("Doubles:");
+        for (unsigned int i = 0; i < msg.doubles.size(); i++)
+          ROS_ERROR("  %s", msg.doubles[i].name.c_str());
+        ROS_ERROR("Strings:");
+        for (unsigned int i = 0; i < msg.strs.size(); i++)
+          ROS_ERROR("  %s", msg.strs[i].name.c_str());
+        // @todo Check that there are no duplicates. Make this error more
+        // explicit.
+        return false;
+      }
+      return true;
+    }
+
+    // This version of __toMessage__ is used during initialization of
+    // statics when __getParamDescriptions__ can't be called yet.
+    void __toMessage__(dynamic_reconfigure::Config &msg, const std::vector<AbstractParamDescriptionConstPtr> &__param_descriptions__, const std::vector<AbstractGroupDescriptionConstPtr> &__group_descriptions__) const
+    {
+      dynamic_reconfigure::ConfigTools::clear(msg);
+      for (std::vector<AbstractParamDescriptionConstPtr>::const_iterator i = __param_descriptions__.begin(); i != __param_descriptions__.end(); ++i)
+        (*i)->toMessage(msg, *this);
+
+      for (std::vector<AbstractGroupDescriptionConstPtr>::const_iterator i = __group_descriptions__.begin(); i != __group_descriptions__.end(); ++i)
+      {
+        if((*i)->id == 0)
+        {
+          (*i)->toMessage(msg, *this);
+        }
+      }
+    }
+
+    void __toMessage__(dynamic_reconfigure::Config &msg) const
+    {
+      const std::vector<AbstractParamDescriptionConstPtr> &__param_descriptions__ = __getParamDescriptions__();
+      const std::vector<AbstractGroupDescriptionConstPtr> &__group_descriptions__ = __getGroupDescriptions__();
+      __toMessage__(msg, __param_descriptions__, __group_descriptions__);
+    }
+
+    void __toServer__(const ros::NodeHandle &nh) const
+    {
+      const std::vector<AbstractParamDescriptionConstPtr> &__param_descriptions__ = __getParamDescriptions__();
+      for (std::vector<AbstractParamDescriptionConstPtr>::const_iterator i = __param_descriptions__.begin(); i != __param_descriptions__.end(); ++i)
+        (*i)->toServer(nh, *this);
+    }
+
+    void __fromServer__(const ros::NodeHandle &nh)
+    {
+      static bool setup=false;
+
+      const std::vector<AbstractParamDescriptionConstPtr> &__param_descriptions__ = __getParamDescriptions__();
+      for (std::vector<AbstractParamDescriptionConstPtr>::const_iterator i = __param_descriptions__.begin(); i != __param_descriptions__.end(); ++i)
+        (*i)->fromServer(nh, *this);
+
+      const std::vector<AbstractGroupDescriptionConstPtr> &__group_descriptions__ = __getGroupDescriptions__();
+      for (std::vector<AbstractGroupDescriptionConstPtr>::const_iterator i = __group_descriptions__.begin(); i != __group_descriptions__.end(); i++){
+        if (!setup && (*i)->id == 0) {
+          setup = true;
+          boost::any n = boost::any(this);
+          (*i)->setInitialState(n);
+        }
+      }
+    }
+
+    void __clamp__()
+    {
+      const std::vector<AbstractParamDescriptionConstPtr> &__param_descriptions__ = __getParamDescriptions__();
+      const CalibrateLinearConfig &__max__ = __getMax__();
+      const CalibrateLinearConfig &__min__ = __getMin__();
+      for (std::vector<AbstractParamDescriptionConstPtr>::const_iterator i = __param_descriptions__.begin(); i != __param_descriptions__.end(); ++i)
+        (*i)->clamp(*this, __max__, __min__);
+    }
+
+    uint32_t __level__(const CalibrateLinearConfig &config) const
+    {
+      const std::vector<AbstractParamDescriptionConstPtr> &__param_descriptions__ = __getParamDescriptions__();
+      uint32_t level = 0;
+      for (std::vector<AbstractParamDescriptionConstPtr>::const_iterator i = __param_descriptions__.begin(); i != __param_descriptions__.end(); ++i)
+        (*i)->calcLevel(level, config, *this);
+      return level;
+    }
+
+    static const dynamic_reconfigure::ConfigDescription &__getDescriptionMessage__();
+    static const CalibrateLinearConfig &__getDefault__();
+    static const CalibrateLinearConfig &__getMax__();
+    static const CalibrateLinearConfig &__getMin__();
+    static const std::vector<AbstractParamDescriptionConstPtr> &__getParamDescriptions__();
+    static const std::vector<AbstractGroupDescriptionConstPtr> &__getGroupDescriptions__();
+
+  private:
+    static const CalibrateLinearConfigStatics *__get_statics__();
+  };
+
+  template <> // Max and min are ignored for strings.
+  inline void CalibrateLinearConfig::ParamDescription<std::string>::clamp(CalibrateLinearConfig &config, const CalibrateLinearConfig &max, const CalibrateLinearConfig &min) const
+  {
+    (void) config;
+    (void) min;
+    (void) max;
+    return;
+  }
+
+  class CalibrateLinearConfigStatics
+  {
+    friend class CalibrateLinearConfig;
+
+    CalibrateLinearConfigStatics()
+    {
+CalibrateLinearConfig::GroupDescription<CalibrateLinearConfig::DEFAULT, CalibrateLinearConfig> Default("Default", "", 0, 0, true, &CalibrateLinearConfig::groups);
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __min__.test_distance = 0.0;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __max__.test_distance = 2.0;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __default__.test_distance = 1.0;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      Default.abstract_parameters.push_back(CalibrateLinearConfig::AbstractParamDescriptionConstPtr(new CalibrateLinearConfig::ParamDescription<double>("test_distance", "double", 0, "Test distance in meters", "", &CalibrateLinearConfig::test_distance)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __param_descriptions__.push_back(CalibrateLinearConfig::AbstractParamDescriptionConstPtr(new CalibrateLinearConfig::ParamDescription<double>("test_distance", "double", 0, "Test distance in meters", "", &CalibrateLinearConfig::test_distance)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __min__.speed = 0.0;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __max__.speed = 0.3;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __default__.speed = 0.15;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      Default.abstract_parameters.push_back(CalibrateLinearConfig::AbstractParamDescriptionConstPtr(new CalibrateLinearConfig::ParamDescription<double>("speed", "double", 0, "Robot speed in meters per second", "", &CalibrateLinearConfig::speed)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __param_descriptions__.push_back(CalibrateLinearConfig::AbstractParamDescriptionConstPtr(new CalibrateLinearConfig::ParamDescription<double>("speed", "double", 0, "Robot speed in meters per second", "", &CalibrateLinearConfig::speed)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __min__.tolerance = 0.0;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __max__.tolerance = 0.1;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __default__.tolerance = 0.01;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      Default.abstract_parameters.push_back(CalibrateLinearConfig::AbstractParamDescriptionConstPtr(new CalibrateLinearConfig::ParamDescription<double>("tolerance", "double", 0, "Error tolerance to goal distance in meters", "", &CalibrateLinearConfig::tolerance)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __param_descriptions__.push_back(CalibrateLinearConfig::AbstractParamDescriptionConstPtr(new CalibrateLinearConfig::ParamDescription<double>("tolerance", "double", 0, "Error tolerance to goal distance in meters", "", &CalibrateLinearConfig::tolerance)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __min__.odom_linear_scale_correction = 0.0;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __max__.odom_linear_scale_correction = 3.0;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __default__.odom_linear_scale_correction = 1.0;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      Default.abstract_parameters.push_back(CalibrateLinearConfig::AbstractParamDescriptionConstPtr(new CalibrateLinearConfig::ParamDescription<double>("odom_linear_scale_correction", "double", 0, "Linear correction factor", "", &CalibrateLinearConfig::odom_linear_scale_correction)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __param_descriptions__.push_back(CalibrateLinearConfig::AbstractParamDescriptionConstPtr(new CalibrateLinearConfig::ParamDescription<double>("odom_linear_scale_correction", "double", 0, "Linear correction factor", "", &CalibrateLinearConfig::odom_linear_scale_correction)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __min__.start_test = 0;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __max__.start_test = 1;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __default__.start_test = 0;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      Default.abstract_parameters.push_back(CalibrateLinearConfig::AbstractParamDescriptionConstPtr(new CalibrateLinearConfig::ParamDescription<bool>("start_test", "bool", 0, "Check to start the test", "", &CalibrateLinearConfig::start_test)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __param_descriptions__.push_back(CalibrateLinearConfig::AbstractParamDescriptionConstPtr(new CalibrateLinearConfig::ParamDescription<bool>("start_test", "bool", 0, "Check to start the test", "", &CalibrateLinearConfig::start_test)));
+//#line 245 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      Default.convertParams();
+//#line 245 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __group_descriptions__.push_back(CalibrateLinearConfig::AbstractGroupDescriptionConstPtr(new CalibrateLinearConfig::GroupDescription<CalibrateLinearConfig::DEFAULT, CalibrateLinearConfig>(Default)));
+//#line 356 "/opt/ros/melodic/share/dynamic_reconfigure/cmake/../templates/ConfigType.h.template"
+
+      for (std::vector<CalibrateLinearConfig::AbstractGroupDescriptionConstPtr>::const_iterator i = __group_descriptions__.begin(); i != __group_descriptions__.end(); ++i)
+      {
+        __description_message__.groups.push_back(**i);
+      }
+      __max__.__toMessage__(__description_message__.max, __param_descriptions__, __group_descriptions__);
+      __min__.__toMessage__(__description_message__.min, __param_descriptions__, __group_descriptions__);
+      __default__.__toMessage__(__description_message__.dflt, __param_descriptions__, __group_descriptions__);
+    }
+    std::vector<CalibrateLinearConfig::AbstractParamDescriptionConstPtr> __param_descriptions__;
+    std::vector<CalibrateLinearConfig::AbstractGroupDescriptionConstPtr> __group_descriptions__;
+    CalibrateLinearConfig __max__;
+    CalibrateLinearConfig __min__;
+    CalibrateLinearConfig __default__;
+    dynamic_reconfigure::ConfigDescription __description_message__;
+
+    static const CalibrateLinearConfigStatics *get_instance()
+    {
+      // Split this off in a separate function because I know that
+      // instance will get initialized the first time get_instance is
+      // called, and I am guaranteeing that get_instance gets called at
+      // most once.
+      static CalibrateLinearConfigStatics instance;
+      return &instance;
+    }
+  };
+
+  inline const dynamic_reconfigure::ConfigDescription &CalibrateLinearConfig::__getDescriptionMessage__()
+  {
+    return __get_statics__()->__description_message__;
+  }
+
+  inline const CalibrateLinearConfig &CalibrateLinearConfig::__getDefault__()
+  {
+    return __get_statics__()->__default__;
+  }
+
+  inline const CalibrateLinearConfig &CalibrateLinearConfig::__getMax__()
+  {
+    return __get_statics__()->__max__;
+  }
+
+  inline const CalibrateLinearConfig &CalibrateLinearConfig::__getMin__()
+  {
+    return __get_statics__()->__min__;
+  }
+
+  inline const std::vector<CalibrateLinearConfig::AbstractParamDescriptionConstPtr> &CalibrateLinearConfig::__getParamDescriptions__()
+  {
+    return __get_statics__()->__param_descriptions__;
+  }
+
+  inline const std::vector<CalibrateLinearConfig::AbstractGroupDescriptionConstPtr> &CalibrateLinearConfig::__getGroupDescriptions__()
+  {
+    return __get_statics__()->__group_descriptions__;
+  }
+
+  inline const CalibrateLinearConfigStatics *CalibrateLinearConfig::__get_statics__()
+  {
+    const static CalibrateLinearConfigStatics *statics;
+
+    if (statics) // Common case
+      return statics;
+
+    boost::mutex::scoped_lock lock(dynamic_reconfigure::__init_mutex__);
+
+    if (statics) // In case we lost a race.
+      return statics;
+
+    statics = CalibrateLinearConfigStatics::get_instance();
+
+    return statics;
+  }
+
+
+}
+
+#endif // __CALIBRATELINEARRECONFIGURATOR_H__

devel/include/sick_tim/SickTimConfig.h

@@ -0,0 +1,559 @@
+//#line 2 "/opt/ros/melodic/share/dynamic_reconfigure/cmake/../templates/ConfigType.h.template"
+// *********************************************************
+//
+// File autogenerated for the sick_tim package
+// by the dynamic_reconfigure package.
+// Please do not edit.
+//
+// ********************************************************/
+
+#ifndef __sick_tim__SICKTIMCONFIG_H__
+#define __sick_tim__SICKTIMCONFIG_H__
+
+#include <dynamic_reconfigure/config_tools.h>
+#include <limits>
+#include <ros/node_handle.h>
+#include <dynamic_reconfigure/ConfigDescription.h>
+#include <dynamic_reconfigure/ParamDescription.h>
+#include <dynamic_reconfigure/Group.h>
+#include <dynamic_reconfigure/config_init_mutex.h>
+#include <boost/any.hpp>
+
+namespace sick_tim
+{
+  class SickTimConfigStatics;
+
+  class SickTimConfig
+  {
+  public:
+    class AbstractParamDescription : public dynamic_reconfigure::ParamDescription
+    {
+    public:
+      AbstractParamDescription(std::string n, std::string t, uint32_t l,
+          std::string d, std::string e)
+      {
+        name = n;
+        type = t;
+        level = l;
+        description = d;
+        edit_method = e;
+      }
+
+      virtual void clamp(SickTimConfig &config, const SickTimConfig &max, const SickTimConfig &min) const = 0;
+      virtual void calcLevel(uint32_t &level, const SickTimConfig &config1, const SickTimConfig &config2) const = 0;
+      virtual void fromServer(const ros::NodeHandle &nh, SickTimConfig &config) const = 0;
+      virtual void toServer(const ros::NodeHandle &nh, const SickTimConfig &config) const = 0;
+      virtual bool fromMessage(const dynamic_reconfigure::Config &msg, SickTimConfig &config) const = 0;
+      virtual void toMessage(dynamic_reconfigure::Config &msg, const SickTimConfig &config) const = 0;
+      virtual void getValue(const SickTimConfig &config, boost::any &val) const = 0;
+    };
+
+    typedef boost::shared_ptr<AbstractParamDescription> AbstractParamDescriptionPtr;
+    typedef boost::shared_ptr<const AbstractParamDescription> AbstractParamDescriptionConstPtr;
+
+    template <class T>
+    class ParamDescription : public AbstractParamDescription
+    {
+    public:
+      ParamDescription(std::string a_name, std::string a_type, uint32_t a_level,
+          std::string a_description, std::string a_edit_method, T SickTimConfig::* a_f) :
+        AbstractParamDescription(a_name, a_type, a_level, a_description, a_edit_method),
+        field(a_f)
+      {}
+
+      T (SickTimConfig::* field);
+
+      virtual void clamp(SickTimConfig &config, const SickTimConfig &max, const SickTimConfig &min) const
+      {
+        if (config.*field > max.*field)
+          config.*field = max.*field;
+
+        if (config.*field < min.*field)
+          config.*field = min.*field;
+      }
+
+      virtual void calcLevel(uint32_t &comb_level, const SickTimConfig &config1, const SickTimConfig &config2) const
+      {
+        if (config1.*field != config2.*field)
+          comb_level |= level;
+      }
+
+      virtual void fromServer(const ros::NodeHandle &nh, SickTimConfig &config) const
+      {
+        nh.getParam(name, config.*field);
+      }
+
+      virtual void toServer(const ros::NodeHandle &nh, const SickTimConfig &config) const
+      {
+        nh.setParam(name, config.*field);
+      }
+
+      virtual bool fromMessage(const dynamic_reconfigure::Config &msg, SickTimConfig &config) const
+      {
+        return dynamic_reconfigure::ConfigTools::getParameter(msg, name, config.*field);
+      }
+
+      virtual void toMessage(dynamic_reconfigure::Config &msg, const SickTimConfig &config) const
+      {
+        dynamic_reconfigure::ConfigTools::appendParameter(msg, name, config.*field);
+      }
+
+      virtual void getValue(const SickTimConfig &config, boost::any &val) const
+      {
+        val = config.*field;
+      }
+    };
+
+    class AbstractGroupDescription : public dynamic_reconfigure::Group
+    {
+      public:
+      AbstractGroupDescription(std::string n, std::string t, int p, int i, bool s)
+      {
+        name = n;
+        type = t;
+        parent = p;
+        state = s;
+        id = i;
+      }
+
+      std::vector<AbstractParamDescriptionConstPtr> abstract_parameters;
+      bool state;
+
+      virtual void toMessage(dynamic_reconfigure::Config &msg, const boost::any &config) const = 0;
+      virtual bool fromMessage(const dynamic_reconfigure::Config &msg, boost::any &config) const =0;
+      virtual void updateParams(boost::any &cfg, SickTimConfig &top) const= 0;
+      virtual void setInitialState(boost::any &cfg) const = 0;
+
+
+      void convertParams()
+      {
+        for(std::vector<AbstractParamDescriptionConstPtr>::const_iterator i = abstract_parameters.begin(); i != abstract_parameters.end(); ++i)
+        {
+          parameters.push_back(dynamic_reconfigure::ParamDescription(**i));
+        }
+      }
+    };
+
+    typedef boost::shared_ptr<AbstractGroupDescription> AbstractGroupDescriptionPtr;
+    typedef boost::shared_ptr<const AbstractGroupDescription> AbstractGroupDescriptionConstPtr;
+
+    template<class T, class PT>
+    class GroupDescription : public AbstractGroupDescription
+    {
+    public:
+      GroupDescription(std::string a_name, std::string a_type, int a_parent, int a_id, bool a_s, T PT::* a_f) : AbstractGroupDescription(a_name, a_type, a_parent, a_id, a_s), field(a_f)
+      {
+      }
+
+      GroupDescription(const GroupDescription<T, PT>& g): AbstractGroupDescription(g.name, g.type, g.parent, g.id, g.state), field(g.field), groups(g.groups)
+      {
+        parameters = g.parameters;
+        abstract_parameters = g.abstract_parameters;
+      }
+
+      virtual bool fromMessage(const dynamic_reconfigure::Config &msg, boost::any &cfg) const
+      {
+        PT* config = boost::any_cast<PT*>(cfg);
+        if(!dynamic_reconfigure::ConfigTools::getGroupState(msg, name, (*config).*field))
+          return false;
+
+        for(std::vector<AbstractGroupDescriptionConstPtr>::const_iterator i = groups.begin(); i != groups.end(); ++i)
+        {
+          boost::any n = &((*config).*field);
+          if(!(*i)->fromMessage(msg, n))
+            return false;
+        }
+
+        return true;
+      }
+
+      virtual void setInitialState(boost::any &cfg) const
+      {
+        PT* config = boost::any_cast<PT*>(cfg);
+        T* group = &((*config).*field);
+        group->state = state;
+
+        for(std::vector<AbstractGroupDescriptionConstPtr>::const_iterator i = groups.begin(); i != groups.end(); ++i)
+        {
+          boost::any n = boost::any(&((*config).*field));
+          (*i)->setInitialState(n);
+        }
+
+      }
+
+      virtual void updateParams(boost::any &cfg, SickTimConfig &top) const
+      {
+        PT* config = boost::any_cast<PT*>(cfg);
+
+        T* f = &((*config).*field);
+        f->setParams(top, abstract_parameters);
+
+        for(std::vector<AbstractGroupDescriptionConstPtr>::const_iterator i = groups.begin(); i != groups.end(); ++i)
+        {
+          boost::any n = &((*config).*field);
+          (*i)->updateParams(n, top);
+        }
+      }
+
+      virtual void toMessage(dynamic_reconfigure::Config &msg, const boost::any &cfg) const
+      {
+        const PT config = boost::any_cast<PT>(cfg);
+        dynamic_reconfigure::ConfigTools::appendGroup<T>(msg, name, id, parent, config.*field);
+
+        for(std::vector<AbstractGroupDescriptionConstPtr>::const_iterator i = groups.begin(); i != groups.end(); ++i)
+        {
+          (*i)->toMessage(msg, config.*field);
+        }
+      }
+
+      T (PT::* field);
+      std::vector<SickTimConfig::AbstractGroupDescriptionConstPtr> groups;
+    };
+
+class DEFAULT
+{
+  public:
+    DEFAULT()
+    {
+      state = true;
+      name = "Default";
+    }
+
+    void setParams(SickTimConfig &config, const std::vector<AbstractParamDescriptionConstPtr> params)
+    {
+      for (std::vector<AbstractParamDescriptionConstPtr>::const_iterator _i = params.begin(); _i != params.end(); ++_i)
+      {
+        boost::any val;
+        (*_i)->getValue(config, val);
+
+        if("min_ang"==(*_i)->name){min_ang = boost::any_cast<double>(val);}
+        if("max_ang"==(*_i)->name){max_ang = boost::any_cast<double>(val);}
+        if("intensity"==(*_i)->name){intensity = boost::any_cast<bool>(val);}
+        if("skip"==(*_i)->name){skip = boost::any_cast<int>(val);}
+        if("frame_id"==(*_i)->name){frame_id = boost::any_cast<std::string>(val);}
+        if("time_offset"==(*_i)->name){time_offset = boost::any_cast<double>(val);}
+        if("auto_reboot"==(*_i)->name){auto_reboot = boost::any_cast<bool>(val);}
+      }
+    }
+
+    double min_ang;
+double max_ang;
+bool intensity;
+int skip;
+std::string frame_id;
+double time_offset;
+bool auto_reboot;
+
+    bool state;
+    std::string name;
+
+    
+}groups;
+
+
+
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      double min_ang;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      double max_ang;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      bool intensity;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      int skip;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      std::string frame_id;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      double time_offset;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      bool auto_reboot;
+//#line 218 "/opt/ros/melodic/share/dynamic_reconfigure/cmake/../templates/ConfigType.h.template"
+
+    bool __fromMessage__(dynamic_reconfigure::Config &msg)
+    {
+      const std::vector<AbstractParamDescriptionConstPtr> &__param_descriptions__ = __getParamDescriptions__();
+      const std::vector<AbstractGroupDescriptionConstPtr> &__group_descriptions__ = __getGroupDescriptions__();
+
+      int count = 0;
+      for (std::vector<AbstractParamDescriptionConstPtr>::const_iterator i = __param_descriptions__.begin(); i != __param_descriptions__.end(); ++i)
+        if ((*i)->fromMessage(msg, *this))
+          count++;
+
+      for (std::vector<AbstractGroupDescriptionConstPtr>::const_iterator i = __group_descriptions__.begin(); i != __group_descriptions__.end(); i ++)
+      {
+        if ((*i)->id == 0)
+        {
+          boost::any n = boost::any(this);
+          (*i)->updateParams(n, *this);
+          (*i)->fromMessage(msg, n);
+        }
+      }
+
+      if (count != dynamic_reconfigure::ConfigTools::size(msg))
+      {
+        ROS_ERROR("SickTimConfig::__fromMessage__ called with an unexpected parameter.");
+        ROS_ERROR("Booleans:");
+        for (unsigned int i = 0; i < msg.bools.size(); i++)
+          ROS_ERROR("  %s", msg.bools[i].name.c_str());
+        ROS_ERROR("Integers:");
+        for (unsigned int i = 0; i < msg.ints.size(); i++)
+          ROS_ERROR("  %s", msg.ints[i].name.c_str());
+        ROS_ERROR("Doubles:");
+        for (unsigned int i = 0; i < msg.doubles.size(); i++)
+          ROS_ERROR("  %s", msg.doubles[i].name.c_str());
+        ROS_ERROR("Strings:");
+        for (unsigned int i = 0; i < msg.strs.size(); i++)
+          ROS_ERROR("  %s", msg.strs[i].name.c_str());
+        // @todo Check that there are no duplicates. Make this error more
+        // explicit.
+        return false;
+      }
+      return true;
+    }
+
+    // This version of __toMessage__ is used during initialization of
+    // statics when __getParamDescriptions__ can't be called yet.
+    void __toMessage__(dynamic_reconfigure::Config &msg, const std::vector<AbstractParamDescriptionConstPtr> &__param_descriptions__, const std::vector<AbstractGroupDescriptionConstPtr> &__group_descriptions__) const
+    {
+      dynamic_reconfigure::ConfigTools::clear(msg);
+      for (std::vector<AbstractParamDescriptionConstPtr>::const_iterator i = __param_descriptions__.begin(); i != __param_descriptions__.end(); ++i)
+        (*i)->toMessage(msg, *this);
+
+      for (std::vector<AbstractGroupDescriptionConstPtr>::const_iterator i = __group_descriptions__.begin(); i != __group_descriptions__.end(); ++i)
+      {
+        if((*i)->id == 0)
+        {
+          (*i)->toMessage(msg, *this);
+        }
+      }
+    }
+
+    void __toMessage__(dynamic_reconfigure::Config &msg) const
+    {
+      const std::vector<AbstractParamDescriptionConstPtr> &__param_descriptions__ = __getParamDescriptions__();
+      const std::vector<AbstractGroupDescriptionConstPtr> &__group_descriptions__ = __getGroupDescriptions__();
+      __toMessage__(msg, __param_descriptions__, __group_descriptions__);
+    }
+
+    void __toServer__(const ros::NodeHandle &nh) const
+    {
+      const std::vector<AbstractParamDescriptionConstPtr> &__param_descriptions__ = __getParamDescriptions__();
+      for (std::vector<AbstractParamDescriptionConstPtr>::const_iterator i = __param_descriptions__.begin(); i != __param_descriptions__.end(); ++i)
+        (*i)->toServer(nh, *this);
+    }
+
+    void __fromServer__(const ros::NodeHandle &nh)
+    {
+      static bool setup=false;
+
+      const std::vector<AbstractParamDescriptionConstPtr> &__param_descriptions__ = __getParamDescriptions__();
+      for (std::vector<AbstractParamDescriptionConstPtr>::const_iterator i = __param_descriptions__.begin(); i != __param_descriptions__.end(); ++i)
+        (*i)->fromServer(nh, *this);
+
+      const std::vector<AbstractGroupDescriptionConstPtr> &__group_descriptions__ = __getGroupDescriptions__();
+      for (std::vector<AbstractGroupDescriptionConstPtr>::const_iterator i = __group_descriptions__.begin(); i != __group_descriptions__.end(); i++){
+        if (!setup && (*i)->id == 0) {
+          setup = true;
+          boost::any n = boost::any(this);
+          (*i)->setInitialState(n);
+        }
+      }
+    }
+
+    void __clamp__()
+    {
+      const std::vector<AbstractParamDescriptionConstPtr> &__param_descriptions__ = __getParamDescriptions__();
+      const SickTimConfig &__max__ = __getMax__();
+      const SickTimConfig &__min__ = __getMin__();
+      for (std::vector<AbstractParamDescriptionConstPtr>::const_iterator i = __param_descriptions__.begin(); i != __param_descriptions__.end(); ++i)
+        (*i)->clamp(*this, __max__, __min__);
+    }
+
+    uint32_t __level__(const SickTimConfig &config) const
+    {
+      const std::vector<AbstractParamDescriptionConstPtr> &__param_descriptions__ = __getParamDescriptions__();
+      uint32_t level = 0;
+      for (std::vector<AbstractParamDescriptionConstPtr>::const_iterator i = __param_descriptions__.begin(); i != __param_descriptions__.end(); ++i)
+        (*i)->calcLevel(level, config, *this);
+      return level;
+    }
+
+    static const dynamic_reconfigure::ConfigDescription &__getDescriptionMessage__();
+    static const SickTimConfig &__getDefault__();
+    static const SickTimConfig &__getMax__();
+    static const SickTimConfig &__getMin__();
+    static const std::vector<AbstractParamDescriptionConstPtr> &__getParamDescriptions__();
+    static const std::vector<AbstractGroupDescriptionConstPtr> &__getGroupDescriptions__();
+
+  private:
+    static const SickTimConfigStatics *__get_statics__();
+  };
+
+  template <> // Max and min are ignored for strings.
+  inline void SickTimConfig::ParamDescription<std::string>::clamp(SickTimConfig &config, const SickTimConfig &max, const SickTimConfig &min) const
+  {
+    (void) config;
+    (void) min;
+    (void) max;
+    return;
+  }
+
+  class SickTimConfigStatics
+  {
+    friend class SickTimConfig;
+
+    SickTimConfigStatics()
+    {
+SickTimConfig::GroupDescription<SickTimConfig::DEFAULT, SickTimConfig> Default("Default", "", 0, 0, true, &SickTimConfig::groups);
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __min__.min_ang = -2.35619449019;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __max__.min_ang = 2.35619449019;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __default__.min_ang = -2.35619449019;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      Default.abstract_parameters.push_back(SickTimConfig::AbstractParamDescriptionConstPtr(new SickTimConfig::ParamDescription<double>("min_ang", "double", 0, "The angle of the first range measurement [rad].", "", &SickTimConfig::min_ang)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __param_descriptions__.push_back(SickTimConfig::AbstractParamDescriptionConstPtr(new SickTimConfig::ParamDescription<double>("min_ang", "double", 0, "The angle of the first range measurement [rad].", "", &SickTimConfig::min_ang)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __min__.max_ang = -2.35619449019;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __max__.max_ang = 2.35619449019;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __default__.max_ang = 2.35619449019;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      Default.abstract_parameters.push_back(SickTimConfig::AbstractParamDescriptionConstPtr(new SickTimConfig::ParamDescription<double>("max_ang", "double", 0, "The angle of the last range measurement [rad].", "", &SickTimConfig::max_ang)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __param_descriptions__.push_back(SickTimConfig::AbstractParamDescriptionConstPtr(new SickTimConfig::ParamDescription<double>("max_ang", "double", 0, "The angle of the last range measurement [rad].", "", &SickTimConfig::max_ang)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __min__.intensity = 0;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __max__.intensity = 1;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __default__.intensity = 1;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      Default.abstract_parameters.push_back(SickTimConfig::AbstractParamDescriptionConstPtr(new SickTimConfig::ParamDescription<bool>("intensity", "bool", 0, "Whether or not to return intensity values. RSSI output must be enabled on scanner (see wiki).", "", &SickTimConfig::intensity)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __param_descriptions__.push_back(SickTimConfig::AbstractParamDescriptionConstPtr(new SickTimConfig::ParamDescription<bool>("intensity", "bool", 0, "Whether or not to return intensity values. RSSI output must be enabled on scanner (see wiki).", "", &SickTimConfig::intensity)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __min__.skip = 0;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __max__.skip = 9;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __default__.skip = 0;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      Default.abstract_parameters.push_back(SickTimConfig::AbstractParamDescriptionConstPtr(new SickTimConfig::ParamDescription<int>("skip", "int", 0, "The number of scans to skip between each measured scan.", "", &SickTimConfig::skip)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __param_descriptions__.push_back(SickTimConfig::AbstractParamDescriptionConstPtr(new SickTimConfig::ParamDescription<int>("skip", "int", 0, "The number of scans to skip between each measured scan.", "", &SickTimConfig::skip)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __min__.frame_id = "";
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __max__.frame_id = "";
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __default__.frame_id = "laser";
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      Default.abstract_parameters.push_back(SickTimConfig::AbstractParamDescriptionConstPtr(new SickTimConfig::ParamDescription<std::string>("frame_id", "str", 0, "The TF frame in which laser scans will be returned.", "", &SickTimConfig::frame_id)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __param_descriptions__.push_back(SickTimConfig::AbstractParamDescriptionConstPtr(new SickTimConfig::ParamDescription<std::string>("frame_id", "str", 0, "The TF frame in which laser scans will be returned.", "", &SickTimConfig::frame_id)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __min__.time_offset = -0.25;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __max__.time_offset = 0.25;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __default__.time_offset = -0.001;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      Default.abstract_parameters.push_back(SickTimConfig::AbstractParamDescriptionConstPtr(new SickTimConfig::ParamDescription<double>("time_offset", "double", 0, "An offset to add to the time stamp before publication of a scan [s].", "", &SickTimConfig::time_offset)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __param_descriptions__.push_back(SickTimConfig::AbstractParamDescriptionConstPtr(new SickTimConfig::ParamDescription<double>("time_offset", "double", 0, "An offset to add to the time stamp before publication of a scan [s].", "", &SickTimConfig::time_offset)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __min__.auto_reboot = 0;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __max__.auto_reboot = 1;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __default__.auto_reboot = 1;
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      Default.abstract_parameters.push_back(SickTimConfig::AbstractParamDescriptionConstPtr(new SickTimConfig::ParamDescription<bool>("auto_reboot", "bool", 0, "Whether or not to reboot laser if it reports an error", "", &SickTimConfig::auto_reboot)));
+//#line 292 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __param_descriptions__.push_back(SickTimConfig::AbstractParamDescriptionConstPtr(new SickTimConfig::ParamDescription<bool>("auto_reboot", "bool", 0, "Whether or not to reboot laser if it reports an error", "", &SickTimConfig::auto_reboot)));
+//#line 245 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      Default.convertParams();
+//#line 245 "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure/parameter_generator_catkin.py"
+      __group_descriptions__.push_back(SickTimConfig::AbstractGroupDescriptionConstPtr(new SickTimConfig::GroupDescription<SickTimConfig::DEFAULT, SickTimConfig>(Default)));
+//#line 356 "/opt/ros/melodic/share/dynamic_reconfigure/cmake/../templates/ConfigType.h.template"
+
+      for (std::vector<SickTimConfig::AbstractGroupDescriptionConstPtr>::const_iterator i = __group_descriptions__.begin(); i != __group_descriptions__.end(); ++i)
+      {
+        __description_message__.groups.push_back(**i);
+      }
+      __max__.__toMessage__(__description_message__.max, __param_descriptions__, __group_descriptions__);
+      __min__.__toMessage__(__description_message__.min, __param_descriptions__, __group_descriptions__);
+      __default__.__toMessage__(__description_message__.dflt, __param_descriptions__, __group_descriptions__);
+    }
+    std::vector<SickTimConfig::AbstractParamDescriptionConstPtr> __param_descriptions__;
+    std::vector<SickTimConfig::AbstractGroupDescriptionConstPtr> __group_descriptions__;
+    SickTimConfig __max__;
+    SickTimConfig __min__;
+    SickTimConfig __default__;
+    dynamic_reconfigure::ConfigDescription __description_message__;
+
+    static const SickTimConfigStatics *get_instance()
+    {
+      // Split this off in a separate function because I know that
+      // instance will get initialized the first time get_instance is
+      // called, and I am guaranteeing that get_instance gets called at
+      // most once.
+      static SickTimConfigStatics instance;
+      return &instance;
+    }
+  };
+
+  inline const dynamic_reconfigure::ConfigDescription &SickTimConfig::__getDescriptionMessage__()
+  {
+    return __get_statics__()->__description_message__;
+  }
+
+  inline const SickTimConfig &SickTimConfig::__getDefault__()
+  {
+    return __get_statics__()->__default__;
+  }
+
+  inline const SickTimConfig &SickTimConfig::__getMax__()
+  {
+    return __get_statics__()->__max__;
+  }
+
+  inline const SickTimConfig &SickTimConfig::__getMin__()
+  {
+    return __get_statics__()->__min__;
+  }
+
+  inline const std::vector<SickTimConfig::AbstractParamDescriptionConstPtr> &SickTimConfig::__getParamDescriptions__()
+  {
+    return __get_statics__()->__param_descriptions__;
+  }
+
+  inline const std::vector<SickTimConfig::AbstractGroupDescriptionConstPtr> &SickTimConfig::__getGroupDescriptions__()
+  {
+    return __get_statics__()->__group_descriptions__;
+  }
+
+  inline const SickTimConfigStatics *SickTimConfig::__get_statics__()
+  {
+    const static SickTimConfigStatics *statics;
+
+    if (statics) // Common case
+      return statics;
+
+    boost::mutex::scoped_lock lock(dynamic_reconfigure::__init_mutex__);
+
+    if (statics) // In case we lost a race.
+      return statics;
+
+    statics = SickTimConfigStatics::get_instance();
+
+    return statics;
+  }
+
+
+}
+
+#endif // __SICKTIMRECONFIGURATOR_H__

devel/lib/pkgconfig/cartographer_ros_msgs.pc

@@ -0,0 +1,8 @@
+prefix=/home/youchen/Documents/catkin_ws/devel
+
+Name: cartographer_ros_msgs
+Description: Description of cartographer_ros_msgs
+Version: 1.0.0
+Cflags: -I/home/youchen/Documents/catkin_ws/devel/include
+Libs: -L/home/youchen/Documents/catkin_ws/devel/lib 
+Requires: geometry_msgs std_msgs message_runtime

devel/lib/pkgconfig/cartographer_rviz.pc

@@ -0,0 +1,8 @@
+prefix=/home/youchen/Documents/catkin_ws/devel
+
+Name: cartographer_rviz
+Description: Description of cartographer_rviz
+Version: 1.0.0
+Cflags: -I/home/youchen/Documents/catkin_ws/src/cartographer_ros/cartographer_rviz/.
+Libs: -L/home/youchen/Documents/catkin_ws/devel/lib 
+Requires: message_runtime cartographer_ros cartographer_ros_msgs eigen_conversions message_runtime roscpp roslib rviz

devel/lib/pkgconfig/gmapping.pc

@@ -0,0 +1,8 @@
+prefix=/home/youchen/Documents/catkin_ws/devel
+
+Name: gmapping
+Description: Description of gmapping
+Version: 1.3.10
+Cflags: 
+Libs: -L/home/youchen/Documents/catkin_ws/devel/lib 
+Requires: 

devel/lib/pkgconfig/laser_bundle.pc

@@ -0,0 +1,8 @@
+prefix=/home/youchen/Documents/catkin_ws/devel
+
+Name: laser_bundle
+Description: Description of laser_bundle
+Version: 0.0.0
+Cflags: 
+Libs: -L/home/youchen/Documents/catkin_ws/devel/lib 
+Requires: 

devel/lib/pkgconfig/laser_scan_matcher.pc

@@ -0,0 +1,8 @@
+prefix=/home/youchen/Documents/catkin_ws/devel
+
+Name: laser_scan_matcher
+Description: Description of laser_scan_matcher
+Version: 0.3.2
+Cflags: -I/home/youchen/Documents/catkin_ws/src/scan_tools/laser_scan_matcher/include
+Libs: -L/home/youchen/Documents/catkin_ws/devel/lib -llaser_scan_matcher
+Requires: roscpp nodelet sensor_msgs tf pcl_ros pcl_conversions geometry_msgs nav_msgs

devel/lib/pkgconfig/mrpt_ekf_slam_2d.pc

@@ -0,0 +1,8 @@
+prefix=/home/youchen/Documents/catkin_ws/devel
+
+Name: mrpt_ekf_slam_2d
+Description: Description of mrpt_ekf_slam_2d
+Version: 0.1.8
+Cflags: 
+Libs: -L/home/youchen/Documents/catkin_ws/devel/lib 
+Requires: nav_msgs sensor_msgs std_msgs visualization_msgs

devel/lib/pkgconfig/mrpt_ekf_slam_3d.pc

@@ -0,0 +1,8 @@
+prefix=/home/youchen/Documents/catkin_ws/devel
+
+Name: mrpt_ekf_slam_3d
+Description: Description of mrpt_ekf_slam_3d
+Version: 0.1.8
+Cflags: 
+Libs: -L/home/youchen/Documents/catkin_ws/devel/lib 
+Requires: nav_msgs sensor_msgs std_msgs visualization_msgs

devel/lib/pkgconfig/openslam_gmapping.pc

@@ -0,0 +1,8 @@
+prefix=/home/youchen/Documents/catkin_ws/devel
+
+Name: openslam_gmapping
+Description: Description of openslam_gmapping
+Version: 0.1.2
+Cflags: -I/home/youchen/Documents/catkin_ws/src/openslam_gmapping/include
+Libs: -L/home/youchen/Documents/catkin_ws/devel/lib -lgridfastslam -lscanmatcher -lsensor_base -lsensor_range -lsensor_odometry -lutils
+Requires: 

devel/lib/pkgconfig/pos_test.pc

@@ -0,0 +1,8 @@
+prefix=/home/youchen/Documents/catkin_ws/devel
+
+Name: pos_test
+Description: Description of pos_test
+Version: 0.0.0
+Cflags: 
+Libs: -L/home/youchen/Documents/catkin_ws/devel/lib 
+Requires: 

devel/lib/pkgconfig/pos_test_cpp.pc

@@ -0,0 +1,8 @@
+prefix=/home/youchen/Documents/catkin_ws/devel
+
+Name: pos_test_cpp
+Description: Description of pos_test_cpp
+Version: 0.0.0
+Cflags: 
+Libs: -L/home/youchen/Documents/catkin_ws/devel/lib 
+Requires: 

devel/lib/pkgconfig/rbx1_apps.pc

@@ -0,0 +1,8 @@
+prefix=/home/youchen/Documents/catkin_ws/devel
+
+Name: rbx1_apps
+Description: Description of rbx1_apps
+Version: 0.4.0
+Cflags: 
+Libs: -L/home/youchen/Documents/catkin_ws/devel/lib 
+Requires: 

devel/lib/pkgconfig/rbx1_bringup.pc

@@ -0,0 +1,8 @@
+prefix=/home/youchen/Documents/catkin_ws/devel
+
+Name: rbx1_bringup
+Description: Description of rbx1_bringup
+Version: 0.4.0
+Cflags: 
+Libs: -L/home/youchen/Documents/catkin_ws/devel/lib 
+Requires: 

devel/lib/pkgconfig/rbx1_description.pc

@@ -0,0 +1,8 @@
+prefix=/home/youchen/Documents/catkin_ws/devel
+
+Name: rbx1_description
+Description: Description of rbx1_description
+Version: 0.4.0
+Cflags: 
+Libs: -L/home/youchen/Documents/catkin_ws/devel/lib 
+Requires: 

devel/lib/pkgconfig/rbx1_dynamixels.pc

@@ -0,0 +1,8 @@
+prefix=/home/youchen/Documents/catkin_ws/devel
+
+Name: rbx1_dynamixels
+Description: Description of rbx1_dynamixels
+Version: 0.4.0
+Cflags: 
+Libs: -L/home/youchen/Documents/catkin_ws/devel/lib 
+Requires: 

devel/lib/pkgconfig/rbx1_nav.pc

@@ -0,0 +1,8 @@
+prefix=/home/youchen/Documents/catkin_ws/devel
+
+Name: rbx1_nav
+Description: Description of rbx1_nav
+Version: 0.4.0
+Cflags: -I/home/youchen/Documents/catkin_ws/devel/include
+Libs: -L/home/youchen/Documents/catkin_ws/devel/lib 
+Requires: dynamic_reconfigure

devel/lib/pkgconfig/rbx1_speech.pc

@@ -0,0 +1,8 @@
+prefix=/home/youchen/Documents/catkin_ws/devel
+
+Name: rbx1_speech
+Description: Description of rbx1_speech
+Version: 0.4.0
+Cflags: 
+Libs: -L/home/youchen/Documents/catkin_ws/devel/lib 
+Requires: 

devel/lib/pkgconfig/rbx1_vision.pc

@@ -0,0 +1,8 @@
+prefix=/home/youchen/Documents/catkin_ws/devel
+
+Name: rbx1_vision
+Description: Description of rbx1_vision
+Version: 0.4.0
+Cflags: 
+Libs: -L/home/youchen/Documents/catkin_ws/devel/lib 
+Requires: 

devel/lib/pkgconfig/sick_tim.pc

@@ -0,0 +1,8 @@
+prefix=/home/youchen/Documents/catkin_ws/devel
+
+Name: sick_tim
+Description: Description of sick_tim
+Version: 0.0.15
+Cflags: -I/home/youchen/Documents/catkin_ws/devel/include -I/home/youchen/Documents/catkin_ws/src/sick_tim/include -I/usr/include -I/usr/include/libusb-1.0
+Libs: -L/home/youchen/Documents/catkin_ws/devel/lib -lsick_tim_3xx /usr/lib/x86_64-linux-gnu/libboost_system.so -lusb-1.0
+Requires: roscpp sensor_msgs diagnostic_updater dynamic_reconfigure

devel/lib/python2.7/dist-packages/cartographer_ros_msgs/msg/_BagfileProgress.py

@@ -0,0 +1,180 @@
+# This Python file uses the following encoding: utf-8
+"""autogenerated by genpy from cartographer_ros_msgs/BagfileProgress.msg. Do not edit."""
+import sys
+python3 = True if sys.hexversion > 0x03000000 else False
+import genpy
+import struct
+
+
+class BagfileProgress(genpy.Message):
+  _md5sum = "2a36f93b13e2b297d45098a38cb00510"
+  _type = "cartographer_ros_msgs/BagfileProgress"
+  _has_header = False #flag to mark the presence of a Header object
+  _full_text = """#
+# Licensed under the Apache License, Version 2.0 (the 'License');
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an 'AS IS' BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# Contains general information about the bagfiles processing progress
+
+string current_bagfile_name
+uint32 current_bagfile_id
+uint32 total_bagfiles
+uint32 total_messages
+uint32 processed_messages
+float32 total_seconds
+float32 processed_seconds
+"""
+  __slots__ = ['current_bagfile_name','current_bagfile_id','total_bagfiles','total_messages','processed_messages','total_seconds','processed_seconds']
+  _slot_types = ['string','uint32','uint32','uint32','uint32','float32','float32']
+
+  def __init__(self, *args, **kwds):
+    """
+    Constructor. Any message fields that are implicitly/explicitly
+    set to None will be assigned a default value. The recommend
+    use is keyword arguments as this is more robust to future message
+    changes.  You cannot mix in-order arguments and keyword arguments.
+
+    The available fields are:
+       current_bagfile_name,current_bagfile_id,total_bagfiles,total_messages,processed_messages,total_seconds,processed_seconds
+
+    :param args: complete set of field values, in .msg order
+    :param kwds: use keyword arguments corresponding to message field names
+    to set specific fields.
+    """
+    if args or kwds:
+      super(BagfileProgress, self).__init__(*args, **kwds)
+      #message fields cannot be None, assign default values for those that are
+      if self.current_bagfile_name is None:
+        self.current_bagfile_name = ''
+      if self.current_bagfile_id is None:
+        self.current_bagfile_id = 0
+      if self.total_bagfiles is None:
+        self.total_bagfiles = 0
+      if self.total_messages is None:
+        self.total_messages = 0
+      if self.processed_messages is None:
+        self.processed_messages = 0
+      if self.total_seconds is None:
+        self.total_seconds = 0.
+      if self.processed_seconds is None:
+        self.processed_seconds = 0.
+    else:
+      self.current_bagfile_name = ''
+      self.current_bagfile_id = 0
+      self.total_bagfiles = 0
+      self.total_messages = 0
+      self.processed_messages = 0
+      self.total_seconds = 0.
+      self.processed_seconds = 0.
+
+  def _get_types(self):
+    """
+    internal API method
+    """
+    return self._slot_types
+
+  def serialize(self, buff):
+    """
+    serialize message into buffer
+    :param buff: buffer, ``StringIO``
+    """
+    try:
+      _x = self.current_bagfile_name
+      length = len(_x)
+      if python3 or type(_x) == unicode:
+        _x = _x.encode('utf-8')
+        length = len(_x)
+      buff.write(struct.pack('<I%ss'%length, length, _x))
+      _x = self
+      buff.write(_get_struct_4I2f().pack(_x.current_bagfile_id, _x.total_bagfiles, _x.total_messages, _x.processed_messages, _x.total_seconds, _x.processed_seconds))
+    except struct.error as se: self._check_types(struct.error("%s: '%s' when writing '%s'" % (type(se), str(se), str(locals().get('_x', self)))))
+    except TypeError as te: self._check_types(ValueError("%s: '%s' when writing '%s'" % (type(te), str(te), str(locals().get('_x', self)))))
+
+  def deserialize(self, str):
+    """
+    unpack serialized message in str into this message instance
+    :param str: byte array of serialized message, ``str``
+    """
+    try:
+      end = 0
+      start = end
+      end += 4
+      (length,) = _struct_I.unpack(str[start:end])
+      start = end
+      end += length
+      if python3:
+        self.current_bagfile_name = str[start:end].decode('utf-8')
+      else:
+        self.current_bagfile_name = str[start:end]
+      _x = self
+      start = end
+      end += 24
+      (_x.current_bagfile_id, _x.total_bagfiles, _x.total_messages, _x.processed_messages, _x.total_seconds, _x.processed_seconds,) = _get_struct_4I2f().unpack(str[start:end])
+      return self
+    except struct.error as e:
+      raise genpy.DeserializationError(e) #most likely buffer underfill
+
+
+  def serialize_numpy(self, buff, numpy):
+    """
+    serialize message with numpy array types into buffer
+    :param buff: buffer, ``StringIO``
+    :param numpy: numpy python module
+    """
+    try:
+      _x = self.current_bagfile_name
+      length = len(_x)
+      if python3 or type(_x) == unicode:
+        _x = _x.encode('utf-8')
+        length = len(_x)
+      buff.write(struct.pack('<I%ss'%length, length, _x))
+      _x = self
+      buff.write(_get_struct_4I2f().pack(_x.current_bagfile_id, _x.total_bagfiles, _x.total_messages, _x.processed_messages, _x.total_seconds, _x.processed_seconds))
+    except struct.error as se: self._check_types(struct.error("%s: '%s' when writing '%s'" % (type(se), str(se), str(locals().get('_x', self)))))
+    except TypeError as te: self._check_types(ValueError("%s: '%s' when writing '%s'" % (type(te), str(te), str(locals().get('_x', self)))))
+
+  def deserialize_numpy(self, str, numpy):
+    """
+    unpack serialized message in str into this message instance using numpy for array types
+    :param str: byte array of serialized message, ``str``
+    :param numpy: numpy python module
+    """
+    try:
+      end = 0
+      start = end
+      end += 4
+      (length,) = _struct_I.unpack(str[start:end])
+      start = end
+      end += length
+      if python3:
+        self.current_bagfile_name = str[start:end].decode('utf-8')
+      else:
+        self.current_bagfile_name = str[start:end]
+      _x = self
+      start = end
+      end += 24
+      (_x.current_bagfile_id, _x.total_bagfiles, _x.total_messages, _x.processed_messages, _x.total_seconds, _x.processed_seconds,) = _get_struct_4I2f().unpack(str[start:end])
+      return self
+    except struct.error as e:
+      raise genpy.DeserializationError(e) #most likely buffer underfill
+
+_struct_I = genpy.struct_I
+def _get_struct_I():
+    global _struct_I
+    return _struct_I
+_struct_4I2f = None
+def _get_struct_4I2f():
+    global _struct_4I2f
+    if _struct_4I2f is None:
+        _struct_4I2f = struct.Struct("<4I2f")
+    return _struct_4I2f