diff --git a/.gitignore b/.gitignore
index bec87ab0eb2a6b38919b2904445fdc93f7d5889b..0d3042ae35bed79e91f719a6b0b66c33de5c4bf0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,5 @@
 /build
 /develop
+src/.idea
+.bag
 .vscode
diff --git a/devel/.built_by b/devel/.built_by
new file mode 100644
index 0000000000000000000000000000000000000000..2e212dd304b5097120ab9fa2ade549804768ad5f
--- /dev/null
+++ b/devel/.built_by
@@ -0,0 +1 @@
+catkin_make
\ No newline at end of file
diff --git a/devel/.catkin b/devel/.catkin
new file mode 100644
index 0000000000000000000000000000000000000000..c66cf056bffa4e258da40fc67fdca1dc108bf1e1
--- /dev/null
+++ b/devel/.catkin
@@ -0,0 +1 @@
+/home/superkuo/Documents/workspace/cv_practice_ws/src;/home/jerry/Documents/workspaces/ROS_human_detection/src
\ No newline at end of file
diff --git a/devel/.rosinstall b/devel/.rosinstall
new file mode 100644
index 0000000000000000000000000000000000000000..51b37bd0e2e7c79f7a89536e3bf0219a5f7d9c4c
--- /dev/null
+++ b/devel/.rosinstall
@@ -0,0 +1,2 @@
+- setup-file:
+    local-name: /home/jerry/Documents/workspaces/ROS_human_detection/devel/setup.sh
diff --git a/devel/_setup_util.py b/devel/_setup_util.py
new file mode 100755
index 0000000000000000000000000000000000000000..f29be0d780f0432631b3de6dcda44524e2173c7a
--- /dev/null
+++ b/devel/_setup_util.py
@@ -0,0 +1,306 @@
+#!/home/jerry/anaconda3/bin/python
+# -*- 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')
+
+PATH_TO_ADD_SUFFIX = ['bin']
+if IS_WINDOWS:
+    # while catkin recommends putting dll's into bin, 3rd party packages often put dll's into lib
+    # since Windows finds dll's via the PATH variable, prepend it with path to lib
+    PATH_TO_ADD_SUFFIX.extend([['lib', os.path.join('lib', 'x86_64-linux-gnu')]])
+
+# 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': PATH_TO_ADD_SUFFIX,
+    'PKG_CONFIG_PATH': [os.path.join('lib', 'pkgconfig'), os.path.join('lib', 'x86_64-linux-gnu', 'pkgconfig')],
+    'PYTHONPATH': 'lib/python3/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')
+    parser.add_argument('--local', action='store_true', help='Only consider this prefix path and ignore other prefix path in the environment')
+    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)
+
+        if not args.local:
+            # environment at generation time
+            CMAKE_PREFIX_PATH = '/home/jerry/Documents/workspaces/ROS_human_detection/devel;/home/jerry/catkin_ws/devel;/opt/ros/kinetic'.split(';')
+        else:
+            # don't consider any other prefix path than this one
+            CMAKE_PREFIX_PATH = []
+        # prepend current workspace if not already part of CPP
+        base_path = os.path.dirname(__file__)
+        # CMAKE_PREFIX_PATH uses forward slash on all platforms, but __file__ is platform dependent
+        # base_path on Windows contains backward slashes, need to be converted to forward slashes before comparison
+        if os.path.sep != '/':
+            base_path = base_path.replace(os.path.sep, '/')
+
+        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)
diff --git a/devel/cmake.lock b/devel/cmake.lock
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/devel/env.sh b/devel/env.sh
new file mode 100755
index 0000000000000000000000000000000000000000..8aa9d244ae9475039027a5f25a8d41a46174cddf
--- /dev/null
+++ b/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 "$@"
diff --git a/devel/include/human_detection/bounding_box.h b/devel/include/human_detection/bounding_box.h
new file mode 100644
index 0000000000000000000000000000000000000000..088a19b5c62d3c82fc50903eff656033cfc929c9
--- /dev/null
+++ b/devel/include/human_detection/bounding_box.h
@@ -0,0 +1,214 @@
+// Generated by gencpp from file human_detection/bounding_box.msg
+// DO NOT EDIT!
+
+
+#ifndef HUMAN_DETECTION_MESSAGE_BOUNDING_BOX_H
+#define HUMAN_DETECTION_MESSAGE_BOUNDING_BOX_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 human_detection
+{
+template <class ContainerAllocator>
+struct bounding_box_
+{
+  typedef bounding_box_<ContainerAllocator> Type;
+
+  bounding_box_()
+    : xmin(0)
+    , xmax(0)
+    , ymin(0)
+    , ymax(0)  {
+    }
+  bounding_box_(const ContainerAllocator& _alloc)
+    : xmin(0)
+    , xmax(0)
+    , ymin(0)
+    , ymax(0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef uint16_t _xmin_type;
+  _xmin_type xmin;
+
+   typedef uint16_t _xmax_type;
+  _xmax_type xmax;
+
+   typedef uint16_t _ymin_type;
+  _ymin_type ymin;
+
+   typedef uint16_t _ymax_type;
+  _ymax_type ymax;
+
+
+
+
+
+  typedef boost::shared_ptr< ::human_detection::bounding_box_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::human_detection::bounding_box_<ContainerAllocator> const> ConstPtr;
+
+}; // struct bounding_box_
+
+typedef ::human_detection::bounding_box_<std::allocator<void> > bounding_box;
+
+typedef boost::shared_ptr< ::human_detection::bounding_box > bounding_boxPtr;
+typedef boost::shared_ptr< ::human_detection::bounding_box const> bounding_boxConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator>
+std::ostream& operator<<(std::ostream& s, const ::human_detection::bounding_box_<ContainerAllocator> & v)
+{
+ros::message_operations::Printer< ::human_detection::bounding_box_<ContainerAllocator> >::stream(s, "", v);
+return s;
+}
+
+} // namespace human_detection
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+// BOOLTRAITS {'IsMessage': True, 'IsFixedSize': True, 'HasHeader': False}
+// {'human_detection': ['/home/jerry/Documents/workspaces/ROS_human_detection/src/human_detection/msg'], 'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg']}
+
+// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__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 IsMessage< ::human_detection::bounding_box_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::human_detection::bounding_box_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::human_detection::bounding_box_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::human_detection::bounding_box_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::human_detection::bounding_box_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::human_detection::bounding_box_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::human_detection::bounding_box_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "0a18150eb9bc571abec460d2df647248";
+  }
+
+  static const char* value(const ::human_detection::bounding_box_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x0a18150eb9bc571aULL;
+  static const uint64_t static_value2 = 0xbec460d2df647248ULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::human_detection::bounding_box_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "human_detection/bounding_box";
+  }
+
+  static const char* value(const ::human_detection::bounding_box_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::human_detection::bounding_box_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "uint16 xmin\n\
+uint16 xmax\n\
+uint16 ymin\n\
+uint16 ymax\n\
+";
+  }
+
+  static const char* value(const ::human_detection::bounding_box_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::human_detection::bounding_box_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
+    {
+      stream.next(m.xmin);
+      stream.next(m.xmax);
+      stream.next(m.ymin);
+      stream.next(m.ymax);
+    }
+
+    ROS_DECLARE_ALLINONE_SERIALIZER
+  }; // struct bounding_box_
+
+} // namespace serialization
+} // namespace ros
+
+namespace ros
+{
+namespace message_operations
+{
+
+template<class ContainerAllocator>
+struct Printer< ::human_detection::bounding_box_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::human_detection::bounding_box_<ContainerAllocator>& v)
+  {
+    s << indent << "xmin: ";
+    Printer<uint16_t>::stream(s, indent + "  ", v.xmin);
+    s << indent << "xmax: ";
+    Printer<uint16_t>::stream(s, indent + "  ", v.xmax);
+    s << indent << "ymin: ";
+    Printer<uint16_t>::stream(s, indent + "  ", v.ymin);
+    s << indent << "ymax: ";
+    Printer<uint16_t>::stream(s, indent + "  ", v.ymax);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // HUMAN_DETECTION_MESSAGE_BOUNDING_BOX_H
diff --git a/devel/lib/pkgconfig/cv2_cvter.pc b/devel/lib/pkgconfig/cv2_cvter.pc
new file mode 100644
index 0000000000000000000000000000000000000000..d24e2fd24753041dd37f218a358295c7e1367e7b
--- /dev/null
+++ b/devel/lib/pkgconfig/cv2_cvter.pc
@@ -0,0 +1,8 @@
+prefix=/home/jerry/Documents/workspaces/ROS_human_detection/devel
+
+Name: cv2_cvter
+Description: Description of cv2_cvter
+Version: 0.0.0
+Cflags: 
+Libs: -L/home/jerry/Documents/workspaces/ROS_human_detection/devel/lib 
+Requires: 
diff --git a/devel/lib/pkgconfig/get_obj_dist.pc b/devel/lib/pkgconfig/get_obj_dist.pc
new file mode 100644
index 0000000000000000000000000000000000000000..5a581388a0f8940ca449cc3de47f3290c7bc5d41
--- /dev/null
+++ b/devel/lib/pkgconfig/get_obj_dist.pc
@@ -0,0 +1,8 @@
+prefix=/home/jerry/Documents/workspaces/ROS_human_detection/devel
+
+Name: get_obj_dist
+Description: Description of get_obj_dist
+Version: 0.0.0
+Cflags: 
+Libs: -L/home/jerry/Documents/workspaces/ROS_human_detection/devel/lib 
+Requires: 
diff --git a/devel/lib/pkgconfig/human_detection.pc b/devel/lib/pkgconfig/human_detection.pc
new file mode 100644
index 0000000000000000000000000000000000000000..1214c940af7d4f4c73fa847075bc7f7dbf0f06b3
--- /dev/null
+++ b/devel/lib/pkgconfig/human_detection.pc
@@ -0,0 +1,8 @@
+prefix=/home/jerry/Documents/workspaces/ROS_human_detection/devel
+
+Name: human_detection
+Description: Description of human_detection
+Version: 0.0.0
+Cflags: -I/home/jerry/Documents/workspaces/ROS_human_detection/devel/include
+Libs: -L/home/jerry/Documents/workspaces/ROS_human_detection/devel/lib 
+Requires: roslib rospy std_msgs message_runtime
diff --git a/devel/lib/pkgconfig/measure_obj_dist.pc b/devel/lib/pkgconfig/measure_obj_dist.pc
new file mode 100644
index 0000000000000000000000000000000000000000..ba4b92abc9c99b69ea0e108f37d2cad9a8dda330
--- /dev/null
+++ b/devel/lib/pkgconfig/measure_obj_dist.pc
@@ -0,0 +1,8 @@
+prefix=/home/jerry/Documents/workspaces/ROS_human_detection/devel
+
+Name: measure_obj_dist
+Description: Description of measure_obj_dist
+Version: 0.0.0
+Cflags: 
+Libs: -L/home/jerry/Documents/workspaces/ROS_human_detection/devel/lib 
+Requires: 
diff --git a/devel/lib/pkgconfig/obj_dist.pc b/devel/lib/pkgconfig/obj_dist.pc
new file mode 100644
index 0000000000000000000000000000000000000000..00d35f963808bf8fad833551b6d0a4143178d3b1
--- /dev/null
+++ b/devel/lib/pkgconfig/obj_dist.pc
@@ -0,0 +1,8 @@
+prefix=/home/jerry/Documents/workspaces/ROS_human_detection/devel
+
+Name: obj_dist
+Description: Description of obj_dist
+Version: 0.0.0
+Cflags: 
+Libs: -L/home/jerry/Documents/workspaces/ROS_human_detection/devel/lib 
+Requires: 
diff --git a/devel/lib/pkgconfig/object_distance.pc b/devel/lib/pkgconfig/object_distance.pc
new file mode 100644
index 0000000000000000000000000000000000000000..7c46c7772c399508999838d4eb85713041351eef
--- /dev/null
+++ b/devel/lib/pkgconfig/object_distance.pc
@@ -0,0 +1,8 @@
+prefix=/home/jerry/Documents/workspaces/ROS_human_detection/devel
+
+Name: object_distance
+Description: Description of object_distance
+Version: 0.0.0
+Cflags: 
+Libs: -L/home/jerry/Documents/workspaces/ROS_human_detection/devel/lib 
+Requires: 
diff --git a/devel/lib/python3/dist-packages/human_detection/__init__.py b/devel/lib/python3/dist-packages/human_detection/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/devel/lib/python3/dist-packages/human_detection/__init__.pyc b/devel/lib/python3/dist-packages/human_detection/__init__.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f1b3b766982a18893984d85ddafd9890536ba6e5
Binary files /dev/null and b/devel/lib/python3/dist-packages/human_detection/__init__.pyc differ
diff --git a/devel/lib/python3/dist-packages/human_detection/msg/__init__.py b/devel/lib/python3/dist-packages/human_detection/msg/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3389142e8b54f0b046874f016bdd3b6acb4dcb49
--- /dev/null
+++ b/devel/lib/python3/dist-packages/human_detection/msg/__init__.py
@@ -0,0 +1 @@
+from ._bounding_box import *
diff --git a/devel/lib/python3/dist-packages/human_detection/msg/__init__.pyc b/devel/lib/python3/dist-packages/human_detection/msg/__init__.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..76d00387ee256175368db2ad3560f7928258c0d4
Binary files /dev/null and b/devel/lib/python3/dist-packages/human_detection/msg/__init__.pyc differ
diff --git a/devel/lib/python3/dist-packages/human_detection/msg/_bounding_box.py b/devel/lib/python3/dist-packages/human_detection/msg/_bounding_box.py
new file mode 100644
index 0000000000000000000000000000000000000000..40595a57588eed1d4aabefee6d265099fa6b298a
--- /dev/null
+++ b/devel/lib/python3/dist-packages/human_detection/msg/_bounding_box.py
@@ -0,0 +1,122 @@
+# This Python file uses the following encoding: utf-8
+"""autogenerated by genpy from human_detection/bounding_box.msg. Do not edit."""
+import sys
+python3 = True if sys.hexversion > 0x03000000 else False
+import genpy
+import struct
+
+
+class bounding_box(genpy.Message):
+  _md5sum = "0a18150eb9bc571abec460d2df647248"
+  _type = "human_detection/bounding_box"
+  _has_header = False #flag to mark the presence of a Header object
+  _full_text = """uint16 xmin
+uint16 xmax
+uint16 ymin
+uint16 ymax
+"""
+  __slots__ = ['xmin','xmax','ymin','ymax']
+  _slot_types = ['uint16','uint16','uint16','uint16']
+
+  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:
+       xmin,xmax,ymin,ymax
+
+    :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(bounding_box, self).__init__(*args, **kwds)
+      #message fields cannot be None, assign default values for those that are
+      if self.xmin is None:
+        self.xmin = 0
+      if self.xmax is None:
+        self.xmax = 0
+      if self.ymin is None:
+        self.ymin = 0
+      if self.ymax is None:
+        self.ymax = 0
+    else:
+      self.xmin = 0
+      self.xmax = 0
+      self.ymin = 0
+      self.ymax = 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
+      buff.write(_get_struct_4H().pack(_x.xmin, _x.xmax, _x.ymin, _x.ymax))
+    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
+      _x = self
+      start = end
+      end += 8
+      (_x.xmin, _x.xmax, _x.ymin, _x.ymax,) = _get_struct_4H().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
+      buff.write(_get_struct_4H().pack(_x.xmin, _x.xmax, _x.ymin, _x.ymax))
+    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
+      _x = self
+      start = end
+      end += 8
+      (_x.xmin, _x.xmax, _x.ymin, _x.ymax,) = _get_struct_4H().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_4H = None
+def _get_struct_4H():
+    global _struct_4H
+    if _struct_4H is None:
+        _struct_4H = struct.Struct("<4H")
+    return _struct_4H
diff --git a/devel/lib/python3/dist-packages/human_detection/msg/_bounding_box.pyc b/devel/lib/python3/dist-packages/human_detection/msg/_bounding_box.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f4bf63a5f0216b1c7db3142939f3dce63d088225
Binary files /dev/null and b/devel/lib/python3/dist-packages/human_detection/msg/_bounding_box.pyc differ
diff --git a/devel/local_setup.bash b/devel/local_setup.bash
new file mode 100644
index 0000000000000000000000000000000000000000..7da0d973d481c97d4aba63ab3a070fdc192dc3f8
--- /dev/null
+++ b/devel/local_setup.bash
@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+# generated from catkin/cmake/templates/local_setup.bash.in
+
+CATKIN_SHELL=bash
+
+# source setup.sh from same directory as this file
+_CATKIN_SETUP_DIR=$(builtin cd "`dirname "${BASH_SOURCE[0]}"`" > /dev/null && pwd)
+. "$_CATKIN_SETUP_DIR/setup.sh" --extend --local
diff --git a/devel/local_setup.sh b/devel/local_setup.sh
new file mode 100644
index 0000000000000000000000000000000000000000..b5b4bf033e66ba77d38c019f1c5eca155d40f277
--- /dev/null
+++ b/devel/local_setup.sh
@@ -0,0 +1,9 @@
+#!/usr/bin/env sh
+# generated from catkin/cmake/template/local_setup.sh.in
+
+# since this file is sourced either use the provided _CATKIN_SETUP_DIR
+# or fall back to the destination set at configure time
+: ${_CATKIN_SETUP_DIR:=/home/jerry/Documents/workspaces/ROS_human_detection/devel}
+CATKIN_SETUP_UTIL_ARGS="--extend --local"
+. "$_CATKIN_SETUP_DIR/setup.sh"
+unset CATKIN_SETUP_UTIL_ARGS
diff --git a/devel/local_setup.zsh b/devel/local_setup.zsh
new file mode 100644
index 0000000000000000000000000000000000000000..e692accfd3341ef2f575dec1c83d843bd786107f
--- /dev/null
+++ b/devel/local_setup.zsh
@@ -0,0 +1,8 @@
+#!/usr/bin/env zsh
+# generated from catkin/cmake/templates/local_setup.zsh.in
+
+CATKIN_SHELL=zsh
+
+# source setup.sh from same directory as this file
+_CATKIN_SETUP_DIR=$(builtin cd -q "`dirname "$0"`" > /dev/null && pwd)
+emulate -R zsh -c 'source "$_CATKIN_SETUP_DIR/setup.sh" --extend --local'
diff --git a/devel/setup.bash b/devel/setup.bash
new file mode 100644
index 0000000000000000000000000000000000000000..ff47af8f30bcc54efd5892530c84c4159250d4a3
--- /dev/null
+++ b/devel/setup.bash
@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+# generated from catkin/cmake/templates/setup.bash.in
+
+CATKIN_SHELL=bash
+
+# source setup.sh from same directory as this file
+_CATKIN_SETUP_DIR=$(builtin cd "`dirname "${BASH_SOURCE[0]}"`" > /dev/null && pwd)
+. "$_CATKIN_SETUP_DIR/setup.sh"
diff --git a/devel/setup.sh b/devel/setup.sh
new file mode 100644
index 0000000000000000000000000000000000000000..c53bd8de70e085fc03116b800ac818087ebbf32a
--- /dev/null
+++ b/devel/setup.sh
@@ -0,0 +1,96 @@
+#!/usr/bin/env sh
+# generated from catkin/cmake/template/setup.sh.in
+
+# Sets various environment variables and sources additional environment hooks.
+# It tries it's best to undo changes from a previously sourced setup file before.
+# Supported command line options:
+# --extend: skips the undoing of changes from a previously sourced setup file
+# --local: only considers this workspace but not the chained ones
+# In plain sh shell which doesn't support arguments for sourced scripts you can
+# set the environment variable `CATKIN_SETUP_UTIL_ARGS=--extend/--local` instead.
+
+# since this file is sourced either use the provided _CATKIN_SETUP_DIR
+# or fall back to the destination set at configure time
+: ${_CATKIN_SETUP_DIR:=/home/jerry/Documents/workspaces/ROS_human_detection/devel}
+_SETUP_UTIL="$_CATKIN_SETUP_DIR/_setup_util.py"
+unset _CATKIN_SETUP_DIR
+
+if [ ! -f "$_SETUP_UTIL" ]; then
+  echo "Missing Python script: $_SETUP_UTIL"
+  return 22
+fi
+
+# detect if running on Darwin platform
+_UNAME=`uname -s`
+_IS_DARWIN=0
+if [ "$_UNAME" = "Darwin" ]; then
+  _IS_DARWIN=1
+fi
+unset _UNAME
+
+# make sure to export all environment variables
+export CMAKE_PREFIX_PATH
+if [ $_IS_DARWIN -eq 0 ]; then
+  export LD_LIBRARY_PATH
+else
+  export DYLD_LIBRARY_PATH
+fi
+unset _IS_DARWIN
+export PATH
+export PKG_CONFIG_PATH
+export PYTHONPATH
+
+# remember type of shell if not already set
+if [ -z "$CATKIN_SHELL" ]; then
+  CATKIN_SHELL=sh
+fi
+
+# invoke Python script to generate necessary exports of environment variables
+# use TMPDIR if it exists, otherwise fall back to /tmp
+if [ -d "${TMPDIR:-}" ]; then
+  _TMPDIR="${TMPDIR}"
+else
+  _TMPDIR=/tmp
+fi
+_SETUP_TMP=`mktemp "${_TMPDIR}/setup.sh.XXXXXXXXXX"`
+unset _TMPDIR
+if [ $? -ne 0 -o ! -f "$_SETUP_TMP" ]; then
+  echo "Could not create temporary file: $_SETUP_TMP"
+  return 1
+fi
+CATKIN_SHELL=$CATKIN_SHELL "$_SETUP_UTIL" $@ ${CATKIN_SETUP_UTIL_ARGS:-} >> "$_SETUP_TMP"
+_RC=$?
+if [ $_RC -ne 0 ]; then
+  if [ $_RC -eq 2 ]; then
+    echo "Could not write the output of '$_SETUP_UTIL' to temporary file '$_SETUP_TMP': may be the disk if full?"
+  else
+    echo "Failed to run '\"$_SETUP_UTIL\" $@': return code $_RC"
+  fi
+  unset _RC
+  unset _SETUP_UTIL
+  rm -f "$_SETUP_TMP"
+  unset _SETUP_TMP
+  return 1
+fi
+unset _RC
+unset _SETUP_UTIL
+. "$_SETUP_TMP"
+rm -f "$_SETUP_TMP"
+unset _SETUP_TMP
+
+# source all environment hooks
+_i=0
+while [ $_i -lt $_CATKIN_ENVIRONMENT_HOOKS_COUNT ]; do
+  eval _envfile=\$_CATKIN_ENVIRONMENT_HOOKS_$_i
+  unset _CATKIN_ENVIRONMENT_HOOKS_$_i
+  eval _envfile_workspace=\$_CATKIN_ENVIRONMENT_HOOKS_${_i}_WORKSPACE
+  unset _CATKIN_ENVIRONMENT_HOOKS_${_i}_WORKSPACE
+  # set workspace for environment hook
+  CATKIN_ENV_HOOK_WORKSPACE=$_envfile_workspace
+  . "$_envfile"
+  unset CATKIN_ENV_HOOK_WORKSPACE
+  _i=$((_i + 1))
+done
+unset _i
+
+unset _CATKIN_ENVIRONMENT_HOOKS_COUNT
diff --git a/devel/setup.zsh b/devel/setup.zsh
new file mode 100644
index 0000000000000000000000000000000000000000..9f780b741031d8037b90514441a80f9fed39d02b
--- /dev/null
+++ b/devel/setup.zsh
@@ -0,0 +1,8 @@
+#!/usr/bin/env zsh
+# generated from catkin/cmake/templates/setup.zsh.in
+
+CATKIN_SHELL=zsh
+
+# source setup.sh from same directory as this file
+_CATKIN_SETUP_DIR=$(builtin cd -q "`dirname "$0"`" > /dev/null && pwd)
+emulate -R zsh -c 'source "$_CATKIN_SETUP_DIR/setup.sh"'
diff --git a/devel/share/common-lisp/ros/human_detection/msg/_package.lisp b/devel/share/common-lisp/ros/human_detection/msg/_package.lisp
new file mode 100644
index 0000000000000000000000000000000000000000..be0b76696f340525a5a4e3f97acee273301f12ab
--- /dev/null
+++ b/devel/share/common-lisp/ros/human_detection/msg/_package.lisp
@@ -0,0 +1,7 @@
+(cl:defpackage human_detection-msg
+  (:use )
+  (:export
+   "<BOUNDING_BOX>"
+   "BOUNDING_BOX"
+  ))
+
diff --git a/devel/share/common-lisp/ros/human_detection/msg/_package_bounding_box.lisp b/devel/share/common-lisp/ros/human_detection/msg/_package_bounding_box.lisp
new file mode 100644
index 0000000000000000000000000000000000000000..b106a064c1001b3a9273a516989d693b3f277e3d
--- /dev/null
+++ b/devel/share/common-lisp/ros/human_detection/msg/_package_bounding_box.lisp
@@ -0,0 +1,10 @@
+(cl:in-package human_detection-msg)
+(cl:export '(XMIN-VAL
+          XMIN
+          XMAX-VAL
+          XMAX
+          YMIN-VAL
+          YMIN
+          YMAX-VAL
+          YMAX
+))
\ No newline at end of file
diff --git a/devel/share/common-lisp/ros/human_detection/msg/bounding_box.lisp b/devel/share/common-lisp/ros/human_detection/msg/bounding_box.lisp
new file mode 100644
index 0000000000000000000000000000000000000000..0239fdfa65a159905c04a27f48fcf2fa2d06ae6d
--- /dev/null
+++ b/devel/share/common-lisp/ros/human_detection/msg/bounding_box.lisp
@@ -0,0 +1,114 @@
+; Auto-generated. Do not edit!
+
+
+(cl:in-package human_detection-msg)
+
+
+;//! \htmlinclude bounding_box.msg.html
+
+(cl:defclass <bounding_box> (roslisp-msg-protocol:ros-message)
+  ((xmin
+    :reader xmin
+    :initarg :xmin
+    :type cl:fixnum
+    :initform 0)
+   (xmax
+    :reader xmax
+    :initarg :xmax
+    :type cl:fixnum
+    :initform 0)
+   (ymin
+    :reader ymin
+    :initarg :ymin
+    :type cl:fixnum
+    :initform 0)
+   (ymax
+    :reader ymax
+    :initarg :ymax
+    :type cl:fixnum
+    :initform 0))
+)
+
+(cl:defclass bounding_box (<bounding_box>)
+  ())
+
+(cl:defmethod cl:initialize-instance :after ((m <bounding_box>) cl:&rest args)
+  (cl:declare (cl:ignorable args))
+  (cl:unless (cl:typep m 'bounding_box)
+    (roslisp-msg-protocol:msg-deprecation-warning "using old message class name human_detection-msg:<bounding_box> is deprecated: use human_detection-msg:bounding_box instead.")))
+
+(cl:ensure-generic-function 'xmin-val :lambda-list '(m))
+(cl:defmethod xmin-val ((m <bounding_box>))
+  (roslisp-msg-protocol:msg-deprecation-warning "Using old-style slot reader human_detection-msg:xmin-val is deprecated.  Use human_detection-msg:xmin instead.")
+  (xmin m))
+
+(cl:ensure-generic-function 'xmax-val :lambda-list '(m))
+(cl:defmethod xmax-val ((m <bounding_box>))
+  (roslisp-msg-protocol:msg-deprecation-warning "Using old-style slot reader human_detection-msg:xmax-val is deprecated.  Use human_detection-msg:xmax instead.")
+  (xmax m))
+
+(cl:ensure-generic-function 'ymin-val :lambda-list '(m))
+(cl:defmethod ymin-val ((m <bounding_box>))
+  (roslisp-msg-protocol:msg-deprecation-warning "Using old-style slot reader human_detection-msg:ymin-val is deprecated.  Use human_detection-msg:ymin instead.")
+  (ymin m))
+
+(cl:ensure-generic-function 'ymax-val :lambda-list '(m))
+(cl:defmethod ymax-val ((m <bounding_box>))
+  (roslisp-msg-protocol:msg-deprecation-warning "Using old-style slot reader human_detection-msg:ymax-val is deprecated.  Use human_detection-msg:ymax instead.")
+  (ymax m))
+(cl:defmethod roslisp-msg-protocol:serialize ((msg <bounding_box>) ostream)
+  "Serializes a message object of type '<bounding_box>"
+  (cl:write-byte (cl:ldb (cl:byte 8 0) (cl:slot-value msg 'xmin)) ostream)
+  (cl:write-byte (cl:ldb (cl:byte 8 8) (cl:slot-value msg 'xmin)) ostream)
+  (cl:write-byte (cl:ldb (cl:byte 8 0) (cl:slot-value msg 'xmax)) ostream)
+  (cl:write-byte (cl:ldb (cl:byte 8 8) (cl:slot-value msg 'xmax)) ostream)
+  (cl:write-byte (cl:ldb (cl:byte 8 0) (cl:slot-value msg 'ymin)) ostream)
+  (cl:write-byte (cl:ldb (cl:byte 8 8) (cl:slot-value msg 'ymin)) ostream)
+  (cl:write-byte (cl:ldb (cl:byte 8 0) (cl:slot-value msg 'ymax)) ostream)
+  (cl:write-byte (cl:ldb (cl:byte 8 8) (cl:slot-value msg 'ymax)) ostream)
+)
+(cl:defmethod roslisp-msg-protocol:deserialize ((msg <bounding_box>) istream)
+  "Deserializes a message object of type '<bounding_box>"
+    (cl:setf (cl:ldb (cl:byte 8 0) (cl:slot-value msg 'xmin)) (cl:read-byte istream))
+    (cl:setf (cl:ldb (cl:byte 8 8) (cl:slot-value msg 'xmin)) (cl:read-byte istream))
+    (cl:setf (cl:ldb (cl:byte 8 0) (cl:slot-value msg 'xmax)) (cl:read-byte istream))
+    (cl:setf (cl:ldb (cl:byte 8 8) (cl:slot-value msg 'xmax)) (cl:read-byte istream))
+    (cl:setf (cl:ldb (cl:byte 8 0) (cl:slot-value msg 'ymin)) (cl:read-byte istream))
+    (cl:setf (cl:ldb (cl:byte 8 8) (cl:slot-value msg 'ymin)) (cl:read-byte istream))
+    (cl:setf (cl:ldb (cl:byte 8 0) (cl:slot-value msg 'ymax)) (cl:read-byte istream))
+    (cl:setf (cl:ldb (cl:byte 8 8) (cl:slot-value msg 'ymax)) (cl:read-byte istream))
+  msg
+)
+(cl:defmethod roslisp-msg-protocol:ros-datatype ((msg (cl:eql '<bounding_box>)))
+  "Returns string type for a message object of type '<bounding_box>"
+  "human_detection/bounding_box")
+(cl:defmethod roslisp-msg-protocol:ros-datatype ((msg (cl:eql 'bounding_box)))
+  "Returns string type for a message object of type 'bounding_box"
+  "human_detection/bounding_box")
+(cl:defmethod roslisp-msg-protocol:md5sum ((type (cl:eql '<bounding_box>)))
+  "Returns md5sum for a message object of type '<bounding_box>"
+  "0a18150eb9bc571abec460d2df647248")
+(cl:defmethod roslisp-msg-protocol:md5sum ((type (cl:eql 'bounding_box)))
+  "Returns md5sum for a message object of type 'bounding_box"
+  "0a18150eb9bc571abec460d2df647248")
+(cl:defmethod roslisp-msg-protocol:message-definition ((type (cl:eql '<bounding_box>)))
+  "Returns full string definition for message of type '<bounding_box>"
+  (cl:format cl:nil "uint16 xmin~%uint16 xmax~%uint16 ymin~%uint16 ymax~%~%~%"))
+(cl:defmethod roslisp-msg-protocol:message-definition ((type (cl:eql 'bounding_box)))
+  "Returns full string definition for message of type 'bounding_box"
+  (cl:format cl:nil "uint16 xmin~%uint16 xmax~%uint16 ymin~%uint16 ymax~%~%~%"))
+(cl:defmethod roslisp-msg-protocol:serialization-length ((msg <bounding_box>))
+  (cl:+ 0
+     2
+     2
+     2
+     2
+))
+(cl:defmethod roslisp-msg-protocol:ros-message-to-list ((msg <bounding_box>))
+  "Converts a ROS message object to a list"
+  (cl:list 'bounding_box
+    (cl:cons ':xmin (xmin msg))
+    (cl:cons ':xmax (xmax msg))
+    (cl:cons ':ymin (ymin msg))
+    (cl:cons ':ymax (ymax msg))
+))
diff --git a/devel/share/common-lisp/ros/human_detection/msg/human_detection-msg.asd b/devel/share/common-lisp/ros/human_detection/msg/human_detection-msg.asd
new file mode 100644
index 0000000000000000000000000000000000000000..d8f3acfbe37499c9510ae058d75042627ed88472
--- /dev/null
+++ b/devel/share/common-lisp/ros/human_detection/msg/human_detection-msg.asd
@@ -0,0 +1,9 @@
+
+(cl:in-package :asdf)
+
+(defsystem "human_detection-msg"
+  :depends-on (:roslisp-msg-protocol :roslisp-utils )
+  :components ((:file "_package")
+    (:file "bounding_box" :depends-on ("_package_bounding_box"))
+    (:file "_package_bounding_box" :depends-on ("_package"))
+  ))
\ No newline at end of file
diff --git a/devel/share/cv2_cvter/cmake/cv2_cvterConfig-version.cmake b/devel/share/cv2_cvter/cmake/cv2_cvterConfig-version.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..7fd9f993a719934b0f7ee411b86bce935627eec0
--- /dev/null
+++ b/devel/share/cv2_cvter/cmake/cv2_cvterConfig-version.cmake
@@ -0,0 +1,14 @@
+# generated from catkin/cmake/template/pkgConfig-version.cmake.in
+set(PACKAGE_VERSION "0.0.0")
+
+set(PACKAGE_VERSION_EXACT False)
+set(PACKAGE_VERSION_COMPATIBLE False)
+
+if("${PACKAGE_FIND_VERSION}" VERSION_EQUAL "${PACKAGE_VERSION}")
+  set(PACKAGE_VERSION_EXACT True)
+  set(PACKAGE_VERSION_COMPATIBLE True)
+endif()
+
+if("${PACKAGE_FIND_VERSION}" VERSION_LESS "${PACKAGE_VERSION}")
+  set(PACKAGE_VERSION_COMPATIBLE True)
+endif()
diff --git a/devel/share/cv2_cvter/cmake/cv2_cvterConfig.cmake b/devel/share/cv2_cvter/cmake/cv2_cvterConfig.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..e7c592dc7873a2a619def0799de1bb2e1cee6d75
--- /dev/null
+++ b/devel/share/cv2_cvter/cmake/cv2_cvterConfig.cmake
@@ -0,0 +1,200 @@
+# generated from catkin/cmake/template/pkgConfig.cmake.in
+
+# append elements to a list and remove existing duplicates from the list
+# copied from catkin/cmake/list_append_deduplicate.cmake to keep pkgConfig
+# self contained
+macro(_list_append_deduplicate listname)
+  if(NOT "${ARGN}" STREQUAL "")
+    if(${listname})
+      list(REMOVE_ITEM ${listname} ${ARGN})
+    endif()
+    list(APPEND ${listname} ${ARGN})
+  endif()
+endmacro()
+
+# append elements to a list if they are not already in the list
+# copied from catkin/cmake/list_append_unique.cmake to keep pkgConfig
+# self contained
+macro(_list_append_unique listname)
+  foreach(_item ${ARGN})
+    list(FIND ${listname} ${_item} _index)
+    if(_index EQUAL -1)
+      list(APPEND ${listname} ${_item})
+    endif()
+  endforeach()
+endmacro()
+
+# pack a list of libraries with optional build configuration keywords
+# copied from catkin/cmake/catkin_libraries.cmake to keep pkgConfig
+# self contained
+macro(_pack_libraries_with_build_configuration VAR)
+  set(${VAR} "")
+  set(_argn ${ARGN})
+  list(LENGTH _argn _count)
+  set(_index 0)
+  while(${_index} LESS ${_count})
+    list(GET _argn ${_index} lib)
+    if("${lib}" MATCHES "^(debug|optimized|general)$")
+      math(EXPR _index "${_index} + 1")
+      if(${_index} EQUAL ${_count})
+        message(FATAL_ERROR "_pack_libraries_with_build_configuration() the list of libraries '${ARGN}' ends with '${lib}' which is a build configuration keyword and must be followed by a library")
+      endif()
+      list(GET _argn ${_index} library)
+      list(APPEND ${VAR} "${lib}${CATKIN_BUILD_CONFIGURATION_KEYWORD_SEPARATOR}${library}")
+    else()
+      list(APPEND ${VAR} "${lib}")
+    endif()
+    math(EXPR _index "${_index} + 1")
+  endwhile()
+endmacro()
+
+# unpack a list of libraries with optional build configuration keyword prefixes
+# copied from catkin/cmake/catkin_libraries.cmake to keep pkgConfig
+# self contained
+macro(_unpack_libraries_with_build_configuration VAR)
+  set(${VAR} "")
+  foreach(lib ${ARGN})
+    string(REGEX REPLACE "^(debug|optimized|general)${CATKIN_BUILD_CONFIGURATION_KEYWORD_SEPARATOR}(.+)$" "\\1;\\2" lib "${lib}")
+    list(APPEND ${VAR} "${lib}")
+  endforeach()
+endmacro()
+
+
+if(cv2_cvter_CONFIG_INCLUDED)
+  return()
+endif()
+set(cv2_cvter_CONFIG_INCLUDED TRUE)
+
+# set variables for source/devel/install prefixes
+if("TRUE" STREQUAL "TRUE")
+  set(cv2_cvter_SOURCE_PREFIX /home/jerry/Documents/workspaces/ROS_human_detection/src/cv2_cvter)
+  set(cv2_cvter_DEVEL_PREFIX /home/jerry/Documents/workspaces/ROS_human_detection/devel)
+  set(cv2_cvter_INSTALL_PREFIX "")
+  set(cv2_cvter_PREFIX ${cv2_cvter_DEVEL_PREFIX})
+else()
+  set(cv2_cvter_SOURCE_PREFIX "")
+  set(cv2_cvter_DEVEL_PREFIX "")
+  set(cv2_cvter_INSTALL_PREFIX /home/jerry/Documents/workspaces/ROS_human_detection/install)
+  set(cv2_cvter_PREFIX ${cv2_cvter_INSTALL_PREFIX})
+endif()
+
+# warn when using a deprecated package
+if(NOT "" STREQUAL "")
+  set(_msg "WARNING: package 'cv2_cvter' is deprecated")
+  # append custom deprecation text if available
+  if(NOT "" STREQUAL "TRUE")
+    set(_msg "${_msg} ()")
+  endif()
+  message("${_msg}")
+endif()
+
+# flag project as catkin-based to distinguish if a find_package()-ed project is a catkin project
+set(cv2_cvter_FOUND_CATKIN_PROJECT TRUE)
+
+if(NOT " " STREQUAL " ")
+  set(cv2_cvter_INCLUDE_DIRS "")
+  set(_include_dirs "")
+  if(NOT " " STREQUAL " ")
+    set(_report "Check the issue tracker '' and consider creating a ticket if the problem has not been reported yet.")
+  elseif(NOT " " STREQUAL " ")
+    set(_report "Check the website '' for information and consider reporting the problem.")
+  else()
+    set(_report "Report the problem to the maintainer 'superkuo <superkuo@todo.todo>' and request to fix the problem.")
+  endif()
+  foreach(idir ${_include_dirs})
+    if(IS_ABSOLUTE ${idir} AND IS_DIRECTORY ${idir})
+      set(include ${idir})
+    elseif("${idir} " STREQUAL "include ")
+      get_filename_component(include "${cv2_cvter_DIR}/../../../include" ABSOLUTE)
+      if(NOT IS_DIRECTORY ${include})
+        message(FATAL_ERROR "Project 'cv2_cvter' specifies '${idir}' as an include dir, which is not found.  It does not exist in '${include}'.  ${_report}")
+      endif()
+    else()
+      message(FATAL_ERROR "Project 'cv2_cvter' specifies '${idir}' as an include dir, which is not found.  It does neither exist as an absolute directory nor in '/home/jerry/Documents/workspaces/ROS_human_detection/src/cv2_cvter/${idir}'.  ${_report}")
+    endif()
+    _list_append_unique(cv2_cvter_INCLUDE_DIRS ${include})
+  endforeach()
+endif()
+
+set(libraries "")
+foreach(library ${libraries})
+  # keep build configuration keywords, target names and absolute libraries as-is
+  if("${library}" MATCHES "^(debug|optimized|general)$")
+    list(APPEND cv2_cvter_LIBRARIES ${library})
+  elseif(${library} MATCHES "^-l")
+    list(APPEND cv2_cvter_LIBRARIES ${library})
+  elseif(TARGET ${library})
+    list(APPEND cv2_cvter_LIBRARIES ${library})
+  elseif(IS_ABSOLUTE ${library})
+    list(APPEND cv2_cvter_LIBRARIES ${library})
+  else()
+    set(lib_path "")
+    set(lib "${library}-NOTFOUND")
+    # since the path where the library is found is returned we have to iterate over the paths manually
+    foreach(path /home/jerry/Documents/workspaces/ROS_human_detection/devel/lib;/home/jerry/catkin_ws/devel/lib;/opt/ros/kinetic/lib)
+      find_library(lib ${library}
+        PATHS ${path}
+        NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
+      if(lib)
+        set(lib_path ${path})
+        break()
+      endif()
+    endforeach()
+    if(lib)
+      _list_append_unique(cv2_cvter_LIBRARY_DIRS ${lib_path})
+      list(APPEND cv2_cvter_LIBRARIES ${lib})
+    else()
+      # as a fall back for non-catkin libraries try to search globally
+      find_library(lib ${library})
+      if(NOT lib)
+        message(FATAL_ERROR "Project '${PROJECT_NAME}' tried to find library '${library}'.  The library is neither a target nor built/installed properly.  Did you compile project 'cv2_cvter'?  Did you find_package() it before the subdirectory containing its code is included?")
+      endif()
+      list(APPEND cv2_cvter_LIBRARIES ${lib})
+    endif()
+  endif()
+endforeach()
+
+set(cv2_cvter_EXPORTED_TARGETS "")
+# create dummy targets for exported code generation targets to make life of users easier
+foreach(t ${cv2_cvter_EXPORTED_TARGETS})
+  if(NOT TARGET ${t})
+    add_custom_target(${t})
+  endif()
+endforeach()
+
+set(depends "")
+foreach(depend ${depends})
+  string(REPLACE " " ";" depend_list ${depend})
+  # the package name of the dependency must be kept in a unique variable so that it is not overwritten in recursive calls
+  list(GET depend_list 0 cv2_cvter_dep)
+  list(LENGTH depend_list count)
+  if(${count} EQUAL 1)
+    # simple dependencies must only be find_package()-ed once
+    if(NOT ${cv2_cvter_dep}_FOUND)
+      find_package(${cv2_cvter_dep} REQUIRED NO_MODULE)
+    endif()
+  else()
+    # dependencies with components must be find_package()-ed again
+    list(REMOVE_AT depend_list 0)
+    find_package(${cv2_cvter_dep} REQUIRED NO_MODULE ${depend_list})
+  endif()
+  _list_append_unique(cv2_cvter_INCLUDE_DIRS ${${cv2_cvter_dep}_INCLUDE_DIRS})
+
+  # merge build configuration keywords with library names to correctly deduplicate
+  _pack_libraries_with_build_configuration(cv2_cvter_LIBRARIES ${cv2_cvter_LIBRARIES})
+  _pack_libraries_with_build_configuration(_libraries ${${cv2_cvter_dep}_LIBRARIES})
+  _list_append_deduplicate(cv2_cvter_LIBRARIES ${_libraries})
+  # undo build configuration keyword merging after deduplication
+  _unpack_libraries_with_build_configuration(cv2_cvter_LIBRARIES ${cv2_cvter_LIBRARIES})
+
+  _list_append_unique(cv2_cvter_LIBRARY_DIRS ${${cv2_cvter_dep}_LIBRARY_DIRS})
+  list(APPEND cv2_cvter_EXPORTED_TARGETS ${${cv2_cvter_dep}_EXPORTED_TARGETS})
+endforeach()
+
+set(pkg_cfg_extras "")
+foreach(extra ${pkg_cfg_extras})
+  if(NOT IS_ABSOLUTE ${extra})
+    set(extra ${cv2_cvter_DIR}/${extra})
+  endif()
+  include(${extra})
+endforeach()
diff --git a/devel/share/gennodejs/ros/human_detection/_index.js b/devel/share/gennodejs/ros/human_detection/_index.js
new file mode 100644
index 0000000000000000000000000000000000000000..74b3dd0b77db25fcbeb3fd1fe3dcf9163b8b2e7c
--- /dev/null
+++ b/devel/share/gennodejs/ros/human_detection/_index.js
@@ -0,0 +1,6 @@
+
+"use strict";
+
+module.exports = {
+  msg: require('./msg/_index.js'),
+};
diff --git a/devel/share/gennodejs/ros/human_detection/msg/_index.js b/devel/share/gennodejs/ros/human_detection/msg/_index.js
new file mode 100644
index 0000000000000000000000000000000000000000..c3284fa4ecb800856d4090fcf448a7fc8f7c3c6c
--- /dev/null
+++ b/devel/share/gennodejs/ros/human_detection/msg/_index.js
@@ -0,0 +1,8 @@
+
+"use strict";
+
+let bounding_box = require('./bounding_box.js');
+
+module.exports = {
+  bounding_box: bounding_box,
+};
diff --git a/devel/share/gennodejs/ros/human_detection/msg/bounding_box.js b/devel/share/gennodejs/ros/human_detection/msg/bounding_box.js
new file mode 100644
index 0000000000000000000000000000000000000000..bf4633b5f280e3dc367496ac905bec610f77435f
--- /dev/null
+++ b/devel/share/gennodejs/ros/human_detection/msg/bounding_box.js
@@ -0,0 +1,145 @@
+// Auto-generated. Do not edit!
+
+// (in-package human_detection.msg)
+
+
+"use strict";
+
+const _serializer = _ros_msg_utils.Serialize;
+const _arraySerializer = _serializer.Array;
+const _deserializer = _ros_msg_utils.Deserialize;
+const _arrayDeserializer = _deserializer.Array;
+const _finder = _ros_msg_utils.Find;
+const _getByteLength = _ros_msg_utils.getByteLength;
+
+//-----------------------------------------------------------
+
+class bounding_box {
+  constructor(initObj={}) {
+    if (initObj === null) {
+      // initObj === null is a special case for deserialization where we don't initialize fields
+      this.xmin = null;
+      this.xmax = null;
+      this.ymin = null;
+      this.ymax = null;
+    }
+    else {
+      if (initObj.hasOwnProperty('xmin')) {
+        this.xmin = initObj.xmin
+      }
+      else {
+        this.xmin = 0;
+      }
+      if (initObj.hasOwnProperty('xmax')) {
+        this.xmax = initObj.xmax
+      }
+      else {
+        this.xmax = 0;
+      }
+      if (initObj.hasOwnProperty('ymin')) {
+        this.ymin = initObj.ymin
+      }
+      else {
+        this.ymin = 0;
+      }
+      if (initObj.hasOwnProperty('ymax')) {
+        this.ymax = initObj.ymax
+      }
+      else {
+        this.ymax = 0;
+      }
+    }
+  }
+
+  static serialize(obj, buffer, bufferOffset) {
+    // Serializes a message object of type bounding_box
+    // Serialize message field [xmin]
+    bufferOffset = _serializer.uint16(obj.xmin, buffer, bufferOffset);
+    // Serialize message field [xmax]
+    bufferOffset = _serializer.uint16(obj.xmax, buffer, bufferOffset);
+    // Serialize message field [ymin]
+    bufferOffset = _serializer.uint16(obj.ymin, buffer, bufferOffset);
+    // Serialize message field [ymax]
+    bufferOffset = _serializer.uint16(obj.ymax, buffer, bufferOffset);
+    return bufferOffset;
+  }
+
+  static deserialize(buffer, bufferOffset=[0]) {
+    //deserializes a message object of type bounding_box
+    let len;
+    let data = new bounding_box(null);
+    // Deserialize message field [xmin]
+    data.xmin = _deserializer.uint16(buffer, bufferOffset);
+    // Deserialize message field [xmax]
+    data.xmax = _deserializer.uint16(buffer, bufferOffset);
+    // Deserialize message field [ymin]
+    data.ymin = _deserializer.uint16(buffer, bufferOffset);
+    // Deserialize message field [ymax]
+    data.ymax = _deserializer.uint16(buffer, bufferOffset);
+    return data;
+  }
+
+  static getMessageSize(object) {
+    return 8;
+  }
+
+  static datatype() {
+    // Returns string type for a message object
+    return 'human_detection/bounding_box';
+  }
+
+  static md5sum() {
+    //Returns md5sum for a message object
+    return '0a18150eb9bc571abec460d2df647248';
+  }
+
+  static messageDefinition() {
+    // Returns full string definition for message
+    return `
+    uint16 xmin
+    uint16 xmax
+    uint16 ymin
+    uint16 ymax
+    
+    `;
+  }
+
+  static Resolve(msg) {
+    // deep-construct a valid message object instance of whatever was passed in
+    if (typeof msg !== 'object' || msg === null) {
+      msg = {};
+    }
+    const resolved = new bounding_box(null);
+    if (msg.xmin !== undefined) {
+      resolved.xmin = msg.xmin;
+    }
+    else {
+      resolved.xmin = 0
+    }
+
+    if (msg.xmax !== undefined) {
+      resolved.xmax = msg.xmax;
+    }
+    else {
+      resolved.xmax = 0
+    }
+
+    if (msg.ymin !== undefined) {
+      resolved.ymin = msg.ymin;
+    }
+    else {
+      resolved.ymin = 0
+    }
+
+    if (msg.ymax !== undefined) {
+      resolved.ymax = msg.ymax;
+    }
+    else {
+      resolved.ymax = 0
+    }
+
+    return resolved;
+    }
+};
+
+module.exports = bounding_box;
diff --git a/devel/share/get_obj_dist/cmake/get_obj_distConfig-version.cmake b/devel/share/get_obj_dist/cmake/get_obj_distConfig-version.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..7fd9f993a719934b0f7ee411b86bce935627eec0
--- /dev/null
+++ b/devel/share/get_obj_dist/cmake/get_obj_distConfig-version.cmake
@@ -0,0 +1,14 @@
+# generated from catkin/cmake/template/pkgConfig-version.cmake.in
+set(PACKAGE_VERSION "0.0.0")
+
+set(PACKAGE_VERSION_EXACT False)
+set(PACKAGE_VERSION_COMPATIBLE False)
+
+if("${PACKAGE_FIND_VERSION}" VERSION_EQUAL "${PACKAGE_VERSION}")
+  set(PACKAGE_VERSION_EXACT True)
+  set(PACKAGE_VERSION_COMPATIBLE True)
+endif()
+
+if("${PACKAGE_FIND_VERSION}" VERSION_LESS "${PACKAGE_VERSION}")
+  set(PACKAGE_VERSION_COMPATIBLE True)
+endif()
diff --git a/devel/share/get_obj_dist/cmake/get_obj_distConfig.cmake b/devel/share/get_obj_dist/cmake/get_obj_distConfig.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..3760998835350fb25be322ee4afa47d5157daeb4
--- /dev/null
+++ b/devel/share/get_obj_dist/cmake/get_obj_distConfig.cmake
@@ -0,0 +1,200 @@
+# generated from catkin/cmake/template/pkgConfig.cmake.in
+
+# append elements to a list and remove existing duplicates from the list
+# copied from catkin/cmake/list_append_deduplicate.cmake to keep pkgConfig
+# self contained
+macro(_list_append_deduplicate listname)
+  if(NOT "${ARGN}" STREQUAL "")
+    if(${listname})
+      list(REMOVE_ITEM ${listname} ${ARGN})
+    endif()
+    list(APPEND ${listname} ${ARGN})
+  endif()
+endmacro()
+
+# append elements to a list if they are not already in the list
+# copied from catkin/cmake/list_append_unique.cmake to keep pkgConfig
+# self contained
+macro(_list_append_unique listname)
+  foreach(_item ${ARGN})
+    list(FIND ${listname} ${_item} _index)
+    if(_index EQUAL -1)
+      list(APPEND ${listname} ${_item})
+    endif()
+  endforeach()
+endmacro()
+
+# pack a list of libraries with optional build configuration keywords
+# copied from catkin/cmake/catkin_libraries.cmake to keep pkgConfig
+# self contained
+macro(_pack_libraries_with_build_configuration VAR)
+  set(${VAR} "")
+  set(_argn ${ARGN})
+  list(LENGTH _argn _count)
+  set(_index 0)
+  while(${_index} LESS ${_count})
+    list(GET _argn ${_index} lib)
+    if("${lib}" MATCHES "^(debug|optimized|general)$")
+      math(EXPR _index "${_index} + 1")
+      if(${_index} EQUAL ${_count})
+        message(FATAL_ERROR "_pack_libraries_with_build_configuration() the list of libraries '${ARGN}' ends with '${lib}' which is a build configuration keyword and must be followed by a library")
+      endif()
+      list(GET _argn ${_index} library)
+      list(APPEND ${VAR} "${lib}${CATKIN_BUILD_CONFIGURATION_KEYWORD_SEPARATOR}${library}")
+    else()
+      list(APPEND ${VAR} "${lib}")
+    endif()
+    math(EXPR _index "${_index} + 1")
+  endwhile()
+endmacro()
+
+# unpack a list of libraries with optional build configuration keyword prefixes
+# copied from catkin/cmake/catkin_libraries.cmake to keep pkgConfig
+# self contained
+macro(_unpack_libraries_with_build_configuration VAR)
+  set(${VAR} "")
+  foreach(lib ${ARGN})
+    string(REGEX REPLACE "^(debug|optimized|general)${CATKIN_BUILD_CONFIGURATION_KEYWORD_SEPARATOR}(.+)$" "\\1;\\2" lib "${lib}")
+    list(APPEND ${VAR} "${lib}")
+  endforeach()
+endmacro()
+
+
+if(get_obj_dist_CONFIG_INCLUDED)
+  return()
+endif()
+set(get_obj_dist_CONFIG_INCLUDED TRUE)
+
+# set variables for source/devel/install prefixes
+if("TRUE" STREQUAL "TRUE")
+  set(get_obj_dist_SOURCE_PREFIX /home/jerry/Documents/workspaces/ROS_human_detection/src/get_obj_dist)
+  set(get_obj_dist_DEVEL_PREFIX /home/jerry/Documents/workspaces/ROS_human_detection/devel)
+  set(get_obj_dist_INSTALL_PREFIX "")
+  set(get_obj_dist_PREFIX ${get_obj_dist_DEVEL_PREFIX})
+else()
+  set(get_obj_dist_SOURCE_PREFIX "")
+  set(get_obj_dist_DEVEL_PREFIX "")
+  set(get_obj_dist_INSTALL_PREFIX /home/jerry/Documents/workspaces/ROS_human_detection/install)
+  set(get_obj_dist_PREFIX ${get_obj_dist_INSTALL_PREFIX})
+endif()
+
+# warn when using a deprecated package
+if(NOT "" STREQUAL "")
+  set(_msg "WARNING: package 'get_obj_dist' is deprecated")
+  # append custom deprecation text if available
+  if(NOT "" STREQUAL "TRUE")
+    set(_msg "${_msg} ()")
+  endif()
+  message("${_msg}")
+endif()
+
+# flag project as catkin-based to distinguish if a find_package()-ed project is a catkin project
+set(get_obj_dist_FOUND_CATKIN_PROJECT TRUE)
+
+if(NOT " " STREQUAL " ")
+  set(get_obj_dist_INCLUDE_DIRS "")
+  set(_include_dirs "")
+  if(NOT " " STREQUAL " ")
+    set(_report "Check the issue tracker '' and consider creating a ticket if the problem has not been reported yet.")
+  elseif(NOT " " STREQUAL " ")
+    set(_report "Check the website '' for information and consider reporting the problem.")
+  else()
+    set(_report "Report the problem to the maintainer 'jerry <jerry@todo.todo>' and request to fix the problem.")
+  endif()
+  foreach(idir ${_include_dirs})
+    if(IS_ABSOLUTE ${idir} AND IS_DIRECTORY ${idir})
+      set(include ${idir})
+    elseif("${idir} " STREQUAL "include ")
+      get_filename_component(include "${get_obj_dist_DIR}/../../../include" ABSOLUTE)
+      if(NOT IS_DIRECTORY ${include})
+        message(FATAL_ERROR "Project 'get_obj_dist' specifies '${idir}' as an include dir, which is not found.  It does not exist in '${include}'.  ${_report}")
+      endif()
+    else()
+      message(FATAL_ERROR "Project 'get_obj_dist' specifies '${idir}' as an include dir, which is not found.  It does neither exist as an absolute directory nor in '/home/jerry/Documents/workspaces/ROS_human_detection/src/get_obj_dist/${idir}'.  ${_report}")
+    endif()
+    _list_append_unique(get_obj_dist_INCLUDE_DIRS ${include})
+  endforeach()
+endif()
+
+set(libraries "")
+foreach(library ${libraries})
+  # keep build configuration keywords, target names and absolute libraries as-is
+  if("${library}" MATCHES "^(debug|optimized|general)$")
+    list(APPEND get_obj_dist_LIBRARIES ${library})
+  elseif(${library} MATCHES "^-l")
+    list(APPEND get_obj_dist_LIBRARIES ${library})
+  elseif(TARGET ${library})
+    list(APPEND get_obj_dist_LIBRARIES ${library})
+  elseif(IS_ABSOLUTE ${library})
+    list(APPEND get_obj_dist_LIBRARIES ${library})
+  else()
+    set(lib_path "")
+    set(lib "${library}-NOTFOUND")
+    # since the path where the library is found is returned we have to iterate over the paths manually
+    foreach(path /home/jerry/Documents/workspaces/ROS_human_detection/devel/lib;/home/jerry/Documents/workspaces/ROS_human_detection/devel/lib;/home/jerry/catkin_ws/devel/lib;/opt/ros/kinetic/lib)
+      find_library(lib ${library}
+        PATHS ${path}
+        NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
+      if(lib)
+        set(lib_path ${path})
+        break()
+      endif()
+    endforeach()
+    if(lib)
+      _list_append_unique(get_obj_dist_LIBRARY_DIRS ${lib_path})
+      list(APPEND get_obj_dist_LIBRARIES ${lib})
+    else()
+      # as a fall back for non-catkin libraries try to search globally
+      find_library(lib ${library})
+      if(NOT lib)
+        message(FATAL_ERROR "Project '${PROJECT_NAME}' tried to find library '${library}'.  The library is neither a target nor built/installed properly.  Did you compile project 'get_obj_dist'?  Did you find_package() it before the subdirectory containing its code is included?")
+      endif()
+      list(APPEND get_obj_dist_LIBRARIES ${lib})
+    endif()
+  endif()
+endforeach()
+
+set(get_obj_dist_EXPORTED_TARGETS "")
+# create dummy targets for exported code generation targets to make life of users easier
+foreach(t ${get_obj_dist_EXPORTED_TARGETS})
+  if(NOT TARGET ${t})
+    add_custom_target(${t})
+  endif()
+endforeach()
+
+set(depends "")
+foreach(depend ${depends})
+  string(REPLACE " " ";" depend_list ${depend})
+  # the package name of the dependency must be kept in a unique variable so that it is not overwritten in recursive calls
+  list(GET depend_list 0 get_obj_dist_dep)
+  list(LENGTH depend_list count)
+  if(${count} EQUAL 1)
+    # simple dependencies must only be find_package()-ed once
+    if(NOT ${get_obj_dist_dep}_FOUND)
+      find_package(${get_obj_dist_dep} REQUIRED NO_MODULE)
+    endif()
+  else()
+    # dependencies with components must be find_package()-ed again
+    list(REMOVE_AT depend_list 0)
+    find_package(${get_obj_dist_dep} REQUIRED NO_MODULE ${depend_list})
+  endif()
+  _list_append_unique(get_obj_dist_INCLUDE_DIRS ${${get_obj_dist_dep}_INCLUDE_DIRS})
+
+  # merge build configuration keywords with library names to correctly deduplicate
+  _pack_libraries_with_build_configuration(get_obj_dist_LIBRARIES ${get_obj_dist_LIBRARIES})
+  _pack_libraries_with_build_configuration(_libraries ${${get_obj_dist_dep}_LIBRARIES})
+  _list_append_deduplicate(get_obj_dist_LIBRARIES ${_libraries})
+  # undo build configuration keyword merging after deduplication
+  _unpack_libraries_with_build_configuration(get_obj_dist_LIBRARIES ${get_obj_dist_LIBRARIES})
+
+  _list_append_unique(get_obj_dist_LIBRARY_DIRS ${${get_obj_dist_dep}_LIBRARY_DIRS})
+  list(APPEND get_obj_dist_EXPORTED_TARGETS ${${get_obj_dist_dep}_EXPORTED_TARGETS})
+endforeach()
+
+set(pkg_cfg_extras "")
+foreach(extra ${pkg_cfg_extras})
+  if(NOT IS_ABSOLUTE ${extra})
+    set(extra ${get_obj_dist_DIR}/${extra})
+  endif()
+  include(${extra})
+endforeach()
diff --git a/devel/share/human_detection/cmake/human_detection-msg-extras.cmake b/devel/share/human_detection/cmake/human_detection-msg-extras.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..25928ceaf3d7f9ddf21b35887d21a2e69dc7ebb0
--- /dev/null
+++ b/devel/share/human_detection/cmake/human_detection-msg-extras.cmake
@@ -0,0 +1,2 @@
+set(human_detection_MESSAGE_FILES "/home/jerry/Documents/workspaces/ROS_human_detection/src/human_detection/msg/bounding_box.msg")
+set(human_detection_SERVICE_FILES "")
diff --git a/devel/share/human_detection/cmake/human_detection-msg-paths.cmake b/devel/share/human_detection/cmake/human_detection-msg-paths.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..ff53e5e1deeea0a82474218341180ca1ffadd37e
--- /dev/null
+++ b/devel/share/human_detection/cmake/human_detection-msg-paths.cmake
@@ -0,0 +1,4 @@
+# generated from genmsg/cmake/pkg-msg-paths.cmake.develspace.in
+
+set(human_detection_MSG_INCLUDE_DIRS "/home/jerry/Documents/workspaces/ROS_human_detection/src/human_detection/msg")
+set(human_detection_MSG_DEPENDENCIES std_msgs)
diff --git a/devel/share/human_detection/cmake/human_detectionConfig-version.cmake b/devel/share/human_detection/cmake/human_detectionConfig-version.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..7fd9f993a719934b0f7ee411b86bce935627eec0
--- /dev/null
+++ b/devel/share/human_detection/cmake/human_detectionConfig-version.cmake
@@ -0,0 +1,14 @@
+# generated from catkin/cmake/template/pkgConfig-version.cmake.in
+set(PACKAGE_VERSION "0.0.0")
+
+set(PACKAGE_VERSION_EXACT False)
+set(PACKAGE_VERSION_COMPATIBLE False)
+
+if("${PACKAGE_FIND_VERSION}" VERSION_EQUAL "${PACKAGE_VERSION}")
+  set(PACKAGE_VERSION_EXACT True)
+  set(PACKAGE_VERSION_COMPATIBLE True)
+endif()
+
+if("${PACKAGE_FIND_VERSION}" VERSION_LESS "${PACKAGE_VERSION}")
+  set(PACKAGE_VERSION_COMPATIBLE True)
+endif()
diff --git a/devel/share/human_detection/cmake/human_detectionConfig.cmake b/devel/share/human_detection/cmake/human_detectionConfig.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..fa8d11b6b45421995e8eae6561c96dab442bf519
--- /dev/null
+++ b/devel/share/human_detection/cmake/human_detectionConfig.cmake
@@ -0,0 +1,200 @@
+# generated from catkin/cmake/template/pkgConfig.cmake.in
+
+# append elements to a list and remove existing duplicates from the list
+# copied from catkin/cmake/list_append_deduplicate.cmake to keep pkgConfig
+# self contained
+macro(_list_append_deduplicate listname)
+  if(NOT "${ARGN}" STREQUAL "")
+    if(${listname})
+      list(REMOVE_ITEM ${listname} ${ARGN})
+    endif()
+    list(APPEND ${listname} ${ARGN})
+  endif()
+endmacro()
+
+# append elements to a list if they are not already in the list
+# copied from catkin/cmake/list_append_unique.cmake to keep pkgConfig
+# self contained
+macro(_list_append_unique listname)
+  foreach(_item ${ARGN})
+    list(FIND ${listname} ${_item} _index)
+    if(_index EQUAL -1)
+      list(APPEND ${listname} ${_item})
+    endif()
+  endforeach()
+endmacro()
+
+# pack a list of libraries with optional build configuration keywords
+# copied from catkin/cmake/catkin_libraries.cmake to keep pkgConfig
+# self contained
+macro(_pack_libraries_with_build_configuration VAR)
+  set(${VAR} "")
+  set(_argn ${ARGN})
+  list(LENGTH _argn _count)
+  set(_index 0)
+  while(${_index} LESS ${_count})
+    list(GET _argn ${_index} lib)
+    if("${lib}" MATCHES "^(debug|optimized|general)$")
+      math(EXPR _index "${_index} + 1")
+      if(${_index} EQUAL ${_count})
+        message(FATAL_ERROR "_pack_libraries_with_build_configuration() the list of libraries '${ARGN}' ends with '${lib}' which is a build configuration keyword and must be followed by a library")
+      endif()
+      list(GET _argn ${_index} library)
+      list(APPEND ${VAR} "${lib}${CATKIN_BUILD_CONFIGURATION_KEYWORD_SEPARATOR}${library}")
+    else()
+      list(APPEND ${VAR} "${lib}")
+    endif()
+    math(EXPR _index "${_index} + 1")
+  endwhile()
+endmacro()
+
+# unpack a list of libraries with optional build configuration keyword prefixes
+# copied from catkin/cmake/catkin_libraries.cmake to keep pkgConfig
+# self contained
+macro(_unpack_libraries_with_build_configuration VAR)
+  set(${VAR} "")
+  foreach(lib ${ARGN})
+    string(REGEX REPLACE "^(debug|optimized|general)${CATKIN_BUILD_CONFIGURATION_KEYWORD_SEPARATOR}(.+)$" "\\1;\\2" lib "${lib}")
+    list(APPEND ${VAR} "${lib}")
+  endforeach()
+endmacro()
+
+
+if(human_detection_CONFIG_INCLUDED)
+  return()
+endif()
+set(human_detection_CONFIG_INCLUDED TRUE)
+
+# set variables for source/devel/install prefixes
+if("TRUE" STREQUAL "TRUE")
+  set(human_detection_SOURCE_PREFIX /home/jerry/Documents/workspaces/ROS_human_detection/src/human_detection)
+  set(human_detection_DEVEL_PREFIX /home/jerry/Documents/workspaces/ROS_human_detection/devel)
+  set(human_detection_INSTALL_PREFIX "")
+  set(human_detection_PREFIX ${human_detection_DEVEL_PREFIX})
+else()
+  set(human_detection_SOURCE_PREFIX "")
+  set(human_detection_DEVEL_PREFIX "")
+  set(human_detection_INSTALL_PREFIX /home/jerry/Documents/workspaces/ROS_human_detection/install)
+  set(human_detection_PREFIX ${human_detection_INSTALL_PREFIX})
+endif()
+
+# warn when using a deprecated package
+if(NOT "" STREQUAL "")
+  set(_msg "WARNING: package 'human_detection' is deprecated")
+  # append custom deprecation text if available
+  if(NOT "" STREQUAL "TRUE")
+    set(_msg "${_msg} ()")
+  endif()
+  message("${_msg}")
+endif()
+
+# flag project as catkin-based to distinguish if a find_package()-ed project is a catkin project
+set(human_detection_FOUND_CATKIN_PROJECT TRUE)
+
+if(NOT "/home/jerry/Documents/workspaces/ROS_human_detection/devel/include " STREQUAL " ")
+  set(human_detection_INCLUDE_DIRS "")
+  set(_include_dirs "/home/jerry/Documents/workspaces/ROS_human_detection/devel/include")
+  if(NOT " " STREQUAL " ")
+    set(_report "Check the issue tracker '' and consider creating a ticket if the problem has not been reported yet.")
+  elseif(NOT " " STREQUAL " ")
+    set(_report "Check the website '' for information and consider reporting the problem.")
+  else()
+    set(_report "Report the problem to the maintainer 'superkuo <superkuo@todo.todo>' and request to fix the problem.")
+  endif()
+  foreach(idir ${_include_dirs})
+    if(IS_ABSOLUTE ${idir} AND IS_DIRECTORY ${idir})
+      set(include ${idir})
+    elseif("${idir} " STREQUAL "include ")
+      get_filename_component(include "${human_detection_DIR}/../../../include" ABSOLUTE)
+      if(NOT IS_DIRECTORY ${include})
+        message(FATAL_ERROR "Project 'human_detection' specifies '${idir}' as an include dir, which is not found.  It does not exist in '${include}'.  ${_report}")
+      endif()
+    else()
+      message(FATAL_ERROR "Project 'human_detection' specifies '${idir}' as an include dir, which is not found.  It does neither exist as an absolute directory nor in '/home/jerry/Documents/workspaces/ROS_human_detection/src/human_detection/${idir}'.  ${_report}")
+    endif()
+    _list_append_unique(human_detection_INCLUDE_DIRS ${include})
+  endforeach()
+endif()
+
+set(libraries "")
+foreach(library ${libraries})
+  # keep build configuration keywords, target names and absolute libraries as-is
+  if("${library}" MATCHES "^(debug|optimized|general)$")
+    list(APPEND human_detection_LIBRARIES ${library})
+  elseif(${library} MATCHES "^-l")
+    list(APPEND human_detection_LIBRARIES ${library})
+  elseif(TARGET ${library})
+    list(APPEND human_detection_LIBRARIES ${library})
+  elseif(IS_ABSOLUTE ${library})
+    list(APPEND human_detection_LIBRARIES ${library})
+  else()
+    set(lib_path "")
+    set(lib "${library}-NOTFOUND")
+    # since the path where the library is found is returned we have to iterate over the paths manually
+    foreach(path /home/jerry/Documents/workspaces/ROS_human_detection/devel/lib;/home/jerry/Documents/workspaces/ROS_human_detection/devel/lib;/home/jerry/catkin_ws/devel/lib;/opt/ros/kinetic/lib)
+      find_library(lib ${library}
+        PATHS ${path}
+        NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
+      if(lib)
+        set(lib_path ${path})
+        break()
+      endif()
+    endforeach()
+    if(lib)
+      _list_append_unique(human_detection_LIBRARY_DIRS ${lib_path})
+      list(APPEND human_detection_LIBRARIES ${lib})
+    else()
+      # as a fall back for non-catkin libraries try to search globally
+      find_library(lib ${library})
+      if(NOT lib)
+        message(FATAL_ERROR "Project '${PROJECT_NAME}' tried to find library '${library}'.  The library is neither a target nor built/installed properly.  Did you compile project 'human_detection'?  Did you find_package() it before the subdirectory containing its code is included?")
+      endif()
+      list(APPEND human_detection_LIBRARIES ${lib})
+    endif()
+  endif()
+endforeach()
+
+set(human_detection_EXPORTED_TARGETS "human_detection_generate_messages_cpp;human_detection_generate_messages_eus;human_detection_generate_messages_lisp;human_detection_generate_messages_nodejs;human_detection_generate_messages_py")
+# create dummy targets for exported code generation targets to make life of users easier
+foreach(t ${human_detection_EXPORTED_TARGETS})
+  if(NOT TARGET ${t})
+    add_custom_target(${t})
+  endif()
+endforeach()
+
+set(depends "roslib;rospy;std_msgs;message_runtime")
+foreach(depend ${depends})
+  string(REPLACE " " ";" depend_list ${depend})
+  # the package name of the dependency must be kept in a unique variable so that it is not overwritten in recursive calls
+  list(GET depend_list 0 human_detection_dep)
+  list(LENGTH depend_list count)
+  if(${count} EQUAL 1)
+    # simple dependencies must only be find_package()-ed once
+    if(NOT ${human_detection_dep}_FOUND)
+      find_package(${human_detection_dep} REQUIRED NO_MODULE)
+    endif()
+  else()
+    # dependencies with components must be find_package()-ed again
+    list(REMOVE_AT depend_list 0)
+    find_package(${human_detection_dep} REQUIRED NO_MODULE ${depend_list})
+  endif()
+  _list_append_unique(human_detection_INCLUDE_DIRS ${${human_detection_dep}_INCLUDE_DIRS})
+
+  # merge build configuration keywords with library names to correctly deduplicate
+  _pack_libraries_with_build_configuration(human_detection_LIBRARIES ${human_detection_LIBRARIES})
+  _pack_libraries_with_build_configuration(_libraries ${${human_detection_dep}_LIBRARIES})
+  _list_append_deduplicate(human_detection_LIBRARIES ${_libraries})
+  # undo build configuration keyword merging after deduplication
+  _unpack_libraries_with_build_configuration(human_detection_LIBRARIES ${human_detection_LIBRARIES})
+
+  _list_append_unique(human_detection_LIBRARY_DIRS ${${human_detection_dep}_LIBRARY_DIRS})
+  list(APPEND human_detection_EXPORTED_TARGETS ${${human_detection_dep}_EXPORTED_TARGETS})
+endforeach()
+
+set(pkg_cfg_extras "human_detection-msg-extras.cmake")
+foreach(extra ${pkg_cfg_extras})
+  if(NOT IS_ABSOLUTE ${extra})
+    set(extra ${human_detection_DIR}/${extra})
+  endif()
+  include(${extra})
+endforeach()
diff --git a/devel/share/measure_obj_dist/cmake/measure_obj_distConfig-version.cmake b/devel/share/measure_obj_dist/cmake/measure_obj_distConfig-version.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..7fd9f993a719934b0f7ee411b86bce935627eec0
--- /dev/null
+++ b/devel/share/measure_obj_dist/cmake/measure_obj_distConfig-version.cmake
@@ -0,0 +1,14 @@
+# generated from catkin/cmake/template/pkgConfig-version.cmake.in
+set(PACKAGE_VERSION "0.0.0")
+
+set(PACKAGE_VERSION_EXACT False)
+set(PACKAGE_VERSION_COMPATIBLE False)
+
+if("${PACKAGE_FIND_VERSION}" VERSION_EQUAL "${PACKAGE_VERSION}")
+  set(PACKAGE_VERSION_EXACT True)
+  set(PACKAGE_VERSION_COMPATIBLE True)
+endif()
+
+if("${PACKAGE_FIND_VERSION}" VERSION_LESS "${PACKAGE_VERSION}")
+  set(PACKAGE_VERSION_COMPATIBLE True)
+endif()
diff --git a/devel/share/measure_obj_dist/cmake/measure_obj_distConfig.cmake b/devel/share/measure_obj_dist/cmake/measure_obj_distConfig.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..e0932d1638bc89518151da721466ada888a66ede
--- /dev/null
+++ b/devel/share/measure_obj_dist/cmake/measure_obj_distConfig.cmake
@@ -0,0 +1,200 @@
+# generated from catkin/cmake/template/pkgConfig.cmake.in
+
+# append elements to a list and remove existing duplicates from the list
+# copied from catkin/cmake/list_append_deduplicate.cmake to keep pkgConfig
+# self contained
+macro(_list_append_deduplicate listname)
+  if(NOT "${ARGN}" STREQUAL "")
+    if(${listname})
+      list(REMOVE_ITEM ${listname} ${ARGN})
+    endif()
+    list(APPEND ${listname} ${ARGN})
+  endif()
+endmacro()
+
+# append elements to a list if they are not already in the list
+# copied from catkin/cmake/list_append_unique.cmake to keep pkgConfig
+# self contained
+macro(_list_append_unique listname)
+  foreach(_item ${ARGN})
+    list(FIND ${listname} ${_item} _index)
+    if(_index EQUAL -1)
+      list(APPEND ${listname} ${_item})
+    endif()
+  endforeach()
+endmacro()
+
+# pack a list of libraries with optional build configuration keywords
+# copied from catkin/cmake/catkin_libraries.cmake to keep pkgConfig
+# self contained
+macro(_pack_libraries_with_build_configuration VAR)
+  set(${VAR} "")
+  set(_argn ${ARGN})
+  list(LENGTH _argn _count)
+  set(_index 0)
+  while(${_index} LESS ${_count})
+    list(GET _argn ${_index} lib)
+    if("${lib}" MATCHES "^(debug|optimized|general)$")
+      math(EXPR _index "${_index} + 1")
+      if(${_index} EQUAL ${_count})
+        message(FATAL_ERROR "_pack_libraries_with_build_configuration() the list of libraries '${ARGN}' ends with '${lib}' which is a build configuration keyword and must be followed by a library")
+      endif()
+      list(GET _argn ${_index} library)
+      list(APPEND ${VAR} "${lib}${CATKIN_BUILD_CONFIGURATION_KEYWORD_SEPARATOR}${library}")
+    else()
+      list(APPEND ${VAR} "${lib}")
+    endif()
+    math(EXPR _index "${_index} + 1")
+  endwhile()
+endmacro()
+
+# unpack a list of libraries with optional build configuration keyword prefixes
+# copied from catkin/cmake/catkin_libraries.cmake to keep pkgConfig
+# self contained
+macro(_unpack_libraries_with_build_configuration VAR)
+  set(${VAR} "")
+  foreach(lib ${ARGN})
+    string(REGEX REPLACE "^(debug|optimized|general)${CATKIN_BUILD_CONFIGURATION_KEYWORD_SEPARATOR}(.+)$" "\\1;\\2" lib "${lib}")
+    list(APPEND ${VAR} "${lib}")
+  endforeach()
+endmacro()
+
+
+if(measure_obj_dist_CONFIG_INCLUDED)
+  return()
+endif()
+set(measure_obj_dist_CONFIG_INCLUDED TRUE)
+
+# set variables for source/devel/install prefixes
+if("TRUE" STREQUAL "TRUE")
+  set(measure_obj_dist_SOURCE_PREFIX /home/jerry/Documents/workspaces/ROS_human_detection/src/measure_obj_dist)
+  set(measure_obj_dist_DEVEL_PREFIX /home/jerry/Documents/workspaces/ROS_human_detection/devel)
+  set(measure_obj_dist_INSTALL_PREFIX "")
+  set(measure_obj_dist_PREFIX ${measure_obj_dist_DEVEL_PREFIX})
+else()
+  set(measure_obj_dist_SOURCE_PREFIX "")
+  set(measure_obj_dist_DEVEL_PREFIX "")
+  set(measure_obj_dist_INSTALL_PREFIX /home/jerry/Documents/workspaces/ROS_human_detection/install)
+  set(measure_obj_dist_PREFIX ${measure_obj_dist_INSTALL_PREFIX})
+endif()
+
+# warn when using a deprecated package
+if(NOT "" STREQUAL "")
+  set(_msg "WARNING: package 'measure_obj_dist' is deprecated")
+  # append custom deprecation text if available
+  if(NOT "" STREQUAL "TRUE")
+    set(_msg "${_msg} ()")
+  endif()
+  message("${_msg}")
+endif()
+
+# flag project as catkin-based to distinguish if a find_package()-ed project is a catkin project
+set(measure_obj_dist_FOUND_CATKIN_PROJECT TRUE)
+
+if(NOT " " STREQUAL " ")
+  set(measure_obj_dist_INCLUDE_DIRS "")
+  set(_include_dirs "")
+  if(NOT " " STREQUAL " ")
+    set(_report "Check the issue tracker '' and consider creating a ticket if the problem has not been reported yet.")
+  elseif(NOT " " STREQUAL " ")
+    set(_report "Check the website '' for information and consider reporting the problem.")
+  else()
+    set(_report "Report the problem to the maintainer 'jerry <jerry@todo.todo>' and request to fix the problem.")
+  endif()
+  foreach(idir ${_include_dirs})
+    if(IS_ABSOLUTE ${idir} AND IS_DIRECTORY ${idir})
+      set(include ${idir})
+    elseif("${idir} " STREQUAL "include ")
+      get_filename_component(include "${measure_obj_dist_DIR}/../../../include" ABSOLUTE)
+      if(NOT IS_DIRECTORY ${include})
+        message(FATAL_ERROR "Project 'measure_obj_dist' specifies '${idir}' as an include dir, which is not found.  It does not exist in '${include}'.  ${_report}")
+      endif()
+    else()
+      message(FATAL_ERROR "Project 'measure_obj_dist' specifies '${idir}' as an include dir, which is not found.  It does neither exist as an absolute directory nor in '/home/jerry/Documents/workspaces/ROS_human_detection/src/measure_obj_dist/${idir}'.  ${_report}")
+    endif()
+    _list_append_unique(measure_obj_dist_INCLUDE_DIRS ${include})
+  endforeach()
+endif()
+
+set(libraries "")
+foreach(library ${libraries})
+  # keep build configuration keywords, target names and absolute libraries as-is
+  if("${library}" MATCHES "^(debug|optimized|general)$")
+    list(APPEND measure_obj_dist_LIBRARIES ${library})
+  elseif(${library} MATCHES "^-l")
+    list(APPEND measure_obj_dist_LIBRARIES ${library})
+  elseif(TARGET ${library})
+    list(APPEND measure_obj_dist_LIBRARIES ${library})
+  elseif(IS_ABSOLUTE ${library})
+    list(APPEND measure_obj_dist_LIBRARIES ${library})
+  else()
+    set(lib_path "")
+    set(lib "${library}-NOTFOUND")
+    # since the path where the library is found is returned we have to iterate over the paths manually
+    foreach(path /home/jerry/Documents/workspaces/ROS_human_detection/devel/lib;/home/jerry/Documents/workspaces/ROS_human_detection/devel/lib;/home/jerry/catkin_ws/devel/lib;/opt/ros/kinetic/lib)
+      find_library(lib ${library}
+        PATHS ${path}
+        NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
+      if(lib)
+        set(lib_path ${path})
+        break()
+      endif()
+    endforeach()
+    if(lib)
+      _list_append_unique(measure_obj_dist_LIBRARY_DIRS ${lib_path})
+      list(APPEND measure_obj_dist_LIBRARIES ${lib})
+    else()
+      # as a fall back for non-catkin libraries try to search globally
+      find_library(lib ${library})
+      if(NOT lib)
+        message(FATAL_ERROR "Project '${PROJECT_NAME}' tried to find library '${library}'.  The library is neither a target nor built/installed properly.  Did you compile project 'measure_obj_dist'?  Did you find_package() it before the subdirectory containing its code is included?")
+      endif()
+      list(APPEND measure_obj_dist_LIBRARIES ${lib})
+    endif()
+  endif()
+endforeach()
+
+set(measure_obj_dist_EXPORTED_TARGETS "")
+# create dummy targets for exported code generation targets to make life of users easier
+foreach(t ${measure_obj_dist_EXPORTED_TARGETS})
+  if(NOT TARGET ${t})
+    add_custom_target(${t})
+  endif()
+endforeach()
+
+set(depends "")
+foreach(depend ${depends})
+  string(REPLACE " " ";" depend_list ${depend})
+  # the package name of the dependency must be kept in a unique variable so that it is not overwritten in recursive calls
+  list(GET depend_list 0 measure_obj_dist_dep)
+  list(LENGTH depend_list count)
+  if(${count} EQUAL 1)
+    # simple dependencies must only be find_package()-ed once
+    if(NOT ${measure_obj_dist_dep}_FOUND)
+      find_package(${measure_obj_dist_dep} REQUIRED NO_MODULE)
+    endif()
+  else()
+    # dependencies with components must be find_package()-ed again
+    list(REMOVE_AT depend_list 0)
+    find_package(${measure_obj_dist_dep} REQUIRED NO_MODULE ${depend_list})
+  endif()
+  _list_append_unique(measure_obj_dist_INCLUDE_DIRS ${${measure_obj_dist_dep}_INCLUDE_DIRS})
+
+  # merge build configuration keywords with library names to correctly deduplicate
+  _pack_libraries_with_build_configuration(measure_obj_dist_LIBRARIES ${measure_obj_dist_LIBRARIES})
+  _pack_libraries_with_build_configuration(_libraries ${${measure_obj_dist_dep}_LIBRARIES})
+  _list_append_deduplicate(measure_obj_dist_LIBRARIES ${_libraries})
+  # undo build configuration keyword merging after deduplication
+  _unpack_libraries_with_build_configuration(measure_obj_dist_LIBRARIES ${measure_obj_dist_LIBRARIES})
+
+  _list_append_unique(measure_obj_dist_LIBRARY_DIRS ${${measure_obj_dist_dep}_LIBRARY_DIRS})
+  list(APPEND measure_obj_dist_EXPORTED_TARGETS ${${measure_obj_dist_dep}_EXPORTED_TARGETS})
+endforeach()
+
+set(pkg_cfg_extras "")
+foreach(extra ${pkg_cfg_extras})
+  if(NOT IS_ABSOLUTE ${extra})
+    set(extra ${measure_obj_dist_DIR}/${extra})
+  endif()
+  include(${extra})
+endforeach()
diff --git a/devel/share/obj_dist/cmake/obj_distConfig-version.cmake b/devel/share/obj_dist/cmake/obj_distConfig-version.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..7fd9f993a719934b0f7ee411b86bce935627eec0
--- /dev/null
+++ b/devel/share/obj_dist/cmake/obj_distConfig-version.cmake
@@ -0,0 +1,14 @@
+# generated from catkin/cmake/template/pkgConfig-version.cmake.in
+set(PACKAGE_VERSION "0.0.0")
+
+set(PACKAGE_VERSION_EXACT False)
+set(PACKAGE_VERSION_COMPATIBLE False)
+
+if("${PACKAGE_FIND_VERSION}" VERSION_EQUAL "${PACKAGE_VERSION}")
+  set(PACKAGE_VERSION_EXACT True)
+  set(PACKAGE_VERSION_COMPATIBLE True)
+endif()
+
+if("${PACKAGE_FIND_VERSION}" VERSION_LESS "${PACKAGE_VERSION}")
+  set(PACKAGE_VERSION_COMPATIBLE True)
+endif()
diff --git a/devel/share/obj_dist/cmake/obj_distConfig.cmake b/devel/share/obj_dist/cmake/obj_distConfig.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..ab3312e3b5efbb798e32f54b2c7a0364873c4010
--- /dev/null
+++ b/devel/share/obj_dist/cmake/obj_distConfig.cmake
@@ -0,0 +1,200 @@
+# generated from catkin/cmake/template/pkgConfig.cmake.in
+
+# append elements to a list and remove existing duplicates from the list
+# copied from catkin/cmake/list_append_deduplicate.cmake to keep pkgConfig
+# self contained
+macro(_list_append_deduplicate listname)
+  if(NOT "${ARGN}" STREQUAL "")
+    if(${listname})
+      list(REMOVE_ITEM ${listname} ${ARGN})
+    endif()
+    list(APPEND ${listname} ${ARGN})
+  endif()
+endmacro()
+
+# append elements to a list if they are not already in the list
+# copied from catkin/cmake/list_append_unique.cmake to keep pkgConfig
+# self contained
+macro(_list_append_unique listname)
+  foreach(_item ${ARGN})
+    list(FIND ${listname} ${_item} _index)
+    if(_index EQUAL -1)
+      list(APPEND ${listname} ${_item})
+    endif()
+  endforeach()
+endmacro()
+
+# pack a list of libraries with optional build configuration keywords
+# copied from catkin/cmake/catkin_libraries.cmake to keep pkgConfig
+# self contained
+macro(_pack_libraries_with_build_configuration VAR)
+  set(${VAR} "")
+  set(_argn ${ARGN})
+  list(LENGTH _argn _count)
+  set(_index 0)
+  while(${_index} LESS ${_count})
+    list(GET _argn ${_index} lib)
+    if("${lib}" MATCHES "^(debug|optimized|general)$")
+      math(EXPR _index "${_index} + 1")
+      if(${_index} EQUAL ${_count})
+        message(FATAL_ERROR "_pack_libraries_with_build_configuration() the list of libraries '${ARGN}' ends with '${lib}' which is a build configuration keyword and must be followed by a library")
+      endif()
+      list(GET _argn ${_index} library)
+      list(APPEND ${VAR} "${lib}${CATKIN_BUILD_CONFIGURATION_KEYWORD_SEPARATOR}${library}")
+    else()
+      list(APPEND ${VAR} "${lib}")
+    endif()
+    math(EXPR _index "${_index} + 1")
+  endwhile()
+endmacro()
+
+# unpack a list of libraries with optional build configuration keyword prefixes
+# copied from catkin/cmake/catkin_libraries.cmake to keep pkgConfig
+# self contained
+macro(_unpack_libraries_with_build_configuration VAR)
+  set(${VAR} "")
+  foreach(lib ${ARGN})
+    string(REGEX REPLACE "^(debug|optimized|general)${CATKIN_BUILD_CONFIGURATION_KEYWORD_SEPARATOR}(.+)$" "\\1;\\2" lib "${lib}")
+    list(APPEND ${VAR} "${lib}")
+  endforeach()
+endmacro()
+
+
+if(obj_dist_CONFIG_INCLUDED)
+  return()
+endif()
+set(obj_dist_CONFIG_INCLUDED TRUE)
+
+# set variables for source/devel/install prefixes
+if("TRUE" STREQUAL "TRUE")
+  set(obj_dist_SOURCE_PREFIX /home/jerry/Documents/workspaces/ROS_human_detection/src/obj_dist)
+  set(obj_dist_DEVEL_PREFIX /home/jerry/Documents/workspaces/ROS_human_detection/devel)
+  set(obj_dist_INSTALL_PREFIX "")
+  set(obj_dist_PREFIX ${obj_dist_DEVEL_PREFIX})
+else()
+  set(obj_dist_SOURCE_PREFIX "")
+  set(obj_dist_DEVEL_PREFIX "")
+  set(obj_dist_INSTALL_PREFIX /home/jerry/Documents/workspaces/ROS_human_detection/install)
+  set(obj_dist_PREFIX ${obj_dist_INSTALL_PREFIX})
+endif()
+
+# warn when using a deprecated package
+if(NOT "" STREQUAL "")
+  set(_msg "WARNING: package 'obj_dist' is deprecated")
+  # append custom deprecation text if available
+  if(NOT "" STREQUAL "TRUE")
+    set(_msg "${_msg} ()")
+  endif()
+  message("${_msg}")
+endif()
+
+# flag project as catkin-based to distinguish if a find_package()-ed project is a catkin project
+set(obj_dist_FOUND_CATKIN_PROJECT TRUE)
+
+if(NOT " " STREQUAL " ")
+  set(obj_dist_INCLUDE_DIRS "")
+  set(_include_dirs "")
+  if(NOT " " STREQUAL " ")
+    set(_report "Check the issue tracker '' and consider creating a ticket if the problem has not been reported yet.")
+  elseif(NOT " " STREQUAL " ")
+    set(_report "Check the website '' for information and consider reporting the problem.")
+  else()
+    set(_report "Report the problem to the maintainer 'jerry <jerry@todo.todo>' and request to fix the problem.")
+  endif()
+  foreach(idir ${_include_dirs})
+    if(IS_ABSOLUTE ${idir} AND IS_DIRECTORY ${idir})
+      set(include ${idir})
+    elseif("${idir} " STREQUAL "include ")
+      get_filename_component(include "${obj_dist_DIR}/../../../include" ABSOLUTE)
+      if(NOT IS_DIRECTORY ${include})
+        message(FATAL_ERROR "Project 'obj_dist' specifies '${idir}' as an include dir, which is not found.  It does not exist in '${include}'.  ${_report}")
+      endif()
+    else()
+      message(FATAL_ERROR "Project 'obj_dist' specifies '${idir}' as an include dir, which is not found.  It does neither exist as an absolute directory nor in '/home/jerry/Documents/workspaces/ROS_human_detection/src/obj_dist/${idir}'.  ${_report}")
+    endif()
+    _list_append_unique(obj_dist_INCLUDE_DIRS ${include})
+  endforeach()
+endif()
+
+set(libraries "")
+foreach(library ${libraries})
+  # keep build configuration keywords, target names and absolute libraries as-is
+  if("${library}" MATCHES "^(debug|optimized|general)$")
+    list(APPEND obj_dist_LIBRARIES ${library})
+  elseif(${library} MATCHES "^-l")
+    list(APPEND obj_dist_LIBRARIES ${library})
+  elseif(TARGET ${library})
+    list(APPEND obj_dist_LIBRARIES ${library})
+  elseif(IS_ABSOLUTE ${library})
+    list(APPEND obj_dist_LIBRARIES ${library})
+  else()
+    set(lib_path "")
+    set(lib "${library}-NOTFOUND")
+    # since the path where the library is found is returned we have to iterate over the paths manually
+    foreach(path /home/jerry/Documents/workspaces/ROS_human_detection/devel/lib;/home/jerry/Documents/workspaces/ROS_human_detection/devel/lib;/home/jerry/catkin_ws/devel/lib;/opt/ros/kinetic/lib)
+      find_library(lib ${library}
+        PATHS ${path}
+        NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
+      if(lib)
+        set(lib_path ${path})
+        break()
+      endif()
+    endforeach()
+    if(lib)
+      _list_append_unique(obj_dist_LIBRARY_DIRS ${lib_path})
+      list(APPEND obj_dist_LIBRARIES ${lib})
+    else()
+      # as a fall back for non-catkin libraries try to search globally
+      find_library(lib ${library})
+      if(NOT lib)
+        message(FATAL_ERROR "Project '${PROJECT_NAME}' tried to find library '${library}'.  The library is neither a target nor built/installed properly.  Did you compile project 'obj_dist'?  Did you find_package() it before the subdirectory containing its code is included?")
+      endif()
+      list(APPEND obj_dist_LIBRARIES ${lib})
+    endif()
+  endif()
+endforeach()
+
+set(obj_dist_EXPORTED_TARGETS "")
+# create dummy targets for exported code generation targets to make life of users easier
+foreach(t ${obj_dist_EXPORTED_TARGETS})
+  if(NOT TARGET ${t})
+    add_custom_target(${t})
+  endif()
+endforeach()
+
+set(depends "")
+foreach(depend ${depends})
+  string(REPLACE " " ";" depend_list ${depend})
+  # the package name of the dependency must be kept in a unique variable so that it is not overwritten in recursive calls
+  list(GET depend_list 0 obj_dist_dep)
+  list(LENGTH depend_list count)
+  if(${count} EQUAL 1)
+    # simple dependencies must only be find_package()-ed once
+    if(NOT ${obj_dist_dep}_FOUND)
+      find_package(${obj_dist_dep} REQUIRED NO_MODULE)
+    endif()
+  else()
+    # dependencies with components must be find_package()-ed again
+    list(REMOVE_AT depend_list 0)
+    find_package(${obj_dist_dep} REQUIRED NO_MODULE ${depend_list})
+  endif()
+  _list_append_unique(obj_dist_INCLUDE_DIRS ${${obj_dist_dep}_INCLUDE_DIRS})
+
+  # merge build configuration keywords with library names to correctly deduplicate
+  _pack_libraries_with_build_configuration(obj_dist_LIBRARIES ${obj_dist_LIBRARIES})
+  _pack_libraries_with_build_configuration(_libraries ${${obj_dist_dep}_LIBRARIES})
+  _list_append_deduplicate(obj_dist_LIBRARIES ${_libraries})
+  # undo build configuration keyword merging after deduplication
+  _unpack_libraries_with_build_configuration(obj_dist_LIBRARIES ${obj_dist_LIBRARIES})
+
+  _list_append_unique(obj_dist_LIBRARY_DIRS ${${obj_dist_dep}_LIBRARY_DIRS})
+  list(APPEND obj_dist_EXPORTED_TARGETS ${${obj_dist_dep}_EXPORTED_TARGETS})
+endforeach()
+
+set(pkg_cfg_extras "")
+foreach(extra ${pkg_cfg_extras})
+  if(NOT IS_ABSOLUTE ${extra})
+    set(extra ${obj_dist_DIR}/${extra})
+  endif()
+  include(${extra})
+endforeach()
diff --git a/devel/share/object_distance/cmake/object_distanceConfig-version.cmake b/devel/share/object_distance/cmake/object_distanceConfig-version.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..7fd9f993a719934b0f7ee411b86bce935627eec0
--- /dev/null
+++ b/devel/share/object_distance/cmake/object_distanceConfig-version.cmake
@@ -0,0 +1,14 @@
+# generated from catkin/cmake/template/pkgConfig-version.cmake.in
+set(PACKAGE_VERSION "0.0.0")
+
+set(PACKAGE_VERSION_EXACT False)
+set(PACKAGE_VERSION_COMPATIBLE False)
+
+if("${PACKAGE_FIND_VERSION}" VERSION_EQUAL "${PACKAGE_VERSION}")
+  set(PACKAGE_VERSION_EXACT True)
+  set(PACKAGE_VERSION_COMPATIBLE True)
+endif()
+
+if("${PACKAGE_FIND_VERSION}" VERSION_LESS "${PACKAGE_VERSION}")
+  set(PACKAGE_VERSION_COMPATIBLE True)
+endif()
diff --git a/devel/share/object_distance/cmake/object_distanceConfig.cmake b/devel/share/object_distance/cmake/object_distanceConfig.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..521d52d47a3a217a7b517bbc57a09b9289dde38b
--- /dev/null
+++ b/devel/share/object_distance/cmake/object_distanceConfig.cmake
@@ -0,0 +1,200 @@
+# generated from catkin/cmake/template/pkgConfig.cmake.in
+
+# append elements to a list and remove existing duplicates from the list
+# copied from catkin/cmake/list_append_deduplicate.cmake to keep pkgConfig
+# self contained
+macro(_list_append_deduplicate listname)
+  if(NOT "${ARGN}" STREQUAL "")
+    if(${listname})
+      list(REMOVE_ITEM ${listname} ${ARGN})
+    endif()
+    list(APPEND ${listname} ${ARGN})
+  endif()
+endmacro()
+
+# append elements to a list if they are not already in the list
+# copied from catkin/cmake/list_append_unique.cmake to keep pkgConfig
+# self contained
+macro(_list_append_unique listname)
+  foreach(_item ${ARGN})
+    list(FIND ${listname} ${_item} _index)
+    if(_index EQUAL -1)
+      list(APPEND ${listname} ${_item})
+    endif()
+  endforeach()
+endmacro()
+
+# pack a list of libraries with optional build configuration keywords
+# copied from catkin/cmake/catkin_libraries.cmake to keep pkgConfig
+# self contained
+macro(_pack_libraries_with_build_configuration VAR)
+  set(${VAR} "")
+  set(_argn ${ARGN})
+  list(LENGTH _argn _count)
+  set(_index 0)
+  while(${_index} LESS ${_count})
+    list(GET _argn ${_index} lib)
+    if("${lib}" MATCHES "^(debug|optimized|general)$")
+      math(EXPR _index "${_index} + 1")
+      if(${_index} EQUAL ${_count})
+        message(FATAL_ERROR "_pack_libraries_with_build_configuration() the list of libraries '${ARGN}' ends with '${lib}' which is a build configuration keyword and must be followed by a library")
+      endif()
+      list(GET _argn ${_index} library)
+      list(APPEND ${VAR} "${lib}${CATKIN_BUILD_CONFIGURATION_KEYWORD_SEPARATOR}${library}")
+    else()
+      list(APPEND ${VAR} "${lib}")
+    endif()
+    math(EXPR _index "${_index} + 1")
+  endwhile()
+endmacro()
+
+# unpack a list of libraries with optional build configuration keyword prefixes
+# copied from catkin/cmake/catkin_libraries.cmake to keep pkgConfig
+# self contained
+macro(_unpack_libraries_with_build_configuration VAR)
+  set(${VAR} "")
+  foreach(lib ${ARGN})
+    string(REGEX REPLACE "^(debug|optimized|general)${CATKIN_BUILD_CONFIGURATION_KEYWORD_SEPARATOR}(.+)$" "\\1;\\2" lib "${lib}")
+    list(APPEND ${VAR} "${lib}")
+  endforeach()
+endmacro()
+
+
+if(object_distance_CONFIG_INCLUDED)
+  return()
+endif()
+set(object_distance_CONFIG_INCLUDED TRUE)
+
+# set variables for source/devel/install prefixes
+if("TRUE" STREQUAL "TRUE")
+  set(object_distance_SOURCE_PREFIX /home/jerry/Documents/workspaces/ROS_human_detection/src/object_distance)
+  set(object_distance_DEVEL_PREFIX /home/jerry/Documents/workspaces/ROS_human_detection/devel)
+  set(object_distance_INSTALL_PREFIX "")
+  set(object_distance_PREFIX ${object_distance_DEVEL_PREFIX})
+else()
+  set(object_distance_SOURCE_PREFIX "")
+  set(object_distance_DEVEL_PREFIX "")
+  set(object_distance_INSTALL_PREFIX /home/jerry/Documents/workspaces/ROS_human_detection/install)
+  set(object_distance_PREFIX ${object_distance_INSTALL_PREFIX})
+endif()
+
+# warn when using a deprecated package
+if(NOT "" STREQUAL "")
+  set(_msg "WARNING: package 'object_distance' is deprecated")
+  # append custom deprecation text if available
+  if(NOT "" STREQUAL "TRUE")
+    set(_msg "${_msg} ()")
+  endif()
+  message("${_msg}")
+endif()
+
+# flag project as catkin-based to distinguish if a find_package()-ed project is a catkin project
+set(object_distance_FOUND_CATKIN_PROJECT TRUE)
+
+if(NOT " " STREQUAL " ")
+  set(object_distance_INCLUDE_DIRS "")
+  set(_include_dirs "")
+  if(NOT " " STREQUAL " ")
+    set(_report "Check the issue tracker '' and consider creating a ticket if the problem has not been reported yet.")
+  elseif(NOT " " STREQUAL " ")
+    set(_report "Check the website '' for information and consider reporting the problem.")
+  else()
+    set(_report "Report the problem to the maintainer 'jerry <jerry@todo.todo>' and request to fix the problem.")
+  endif()
+  foreach(idir ${_include_dirs})
+    if(IS_ABSOLUTE ${idir} AND IS_DIRECTORY ${idir})
+      set(include ${idir})
+    elseif("${idir} " STREQUAL "include ")
+      get_filename_component(include "${object_distance_DIR}/../../../include" ABSOLUTE)
+      if(NOT IS_DIRECTORY ${include})
+        message(FATAL_ERROR "Project 'object_distance' specifies '${idir}' as an include dir, which is not found.  It does not exist in '${include}'.  ${_report}")
+      endif()
+    else()
+      message(FATAL_ERROR "Project 'object_distance' specifies '${idir}' as an include dir, which is not found.  It does neither exist as an absolute directory nor in '/home/jerry/Documents/workspaces/ROS_human_detection/src/object_distance/${idir}'.  ${_report}")
+    endif()
+    _list_append_unique(object_distance_INCLUDE_DIRS ${include})
+  endforeach()
+endif()
+
+set(libraries "")
+foreach(library ${libraries})
+  # keep build configuration keywords, target names and absolute libraries as-is
+  if("${library}" MATCHES "^(debug|optimized|general)$")
+    list(APPEND object_distance_LIBRARIES ${library})
+  elseif(${library} MATCHES "^-l")
+    list(APPEND object_distance_LIBRARIES ${library})
+  elseif(TARGET ${library})
+    list(APPEND object_distance_LIBRARIES ${library})
+  elseif(IS_ABSOLUTE ${library})
+    list(APPEND object_distance_LIBRARIES ${library})
+  else()
+    set(lib_path "")
+    set(lib "${library}-NOTFOUND")
+    # since the path where the library is found is returned we have to iterate over the paths manually
+    foreach(path /home/jerry/Documents/workspaces/ROS_human_detection/devel/lib;/home/jerry/Documents/workspaces/ROS_human_detection/devel/lib;/home/jerry/catkin_ws/devel/lib;/opt/ros/kinetic/lib)
+      find_library(lib ${library}
+        PATHS ${path}
+        NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
+      if(lib)
+        set(lib_path ${path})
+        break()
+      endif()
+    endforeach()
+    if(lib)
+      _list_append_unique(object_distance_LIBRARY_DIRS ${lib_path})
+      list(APPEND object_distance_LIBRARIES ${lib})
+    else()
+      # as a fall back for non-catkin libraries try to search globally
+      find_library(lib ${library})
+      if(NOT lib)
+        message(FATAL_ERROR "Project '${PROJECT_NAME}' tried to find library '${library}'.  The library is neither a target nor built/installed properly.  Did you compile project 'object_distance'?  Did you find_package() it before the subdirectory containing its code is included?")
+      endif()
+      list(APPEND object_distance_LIBRARIES ${lib})
+    endif()
+  endif()
+endforeach()
+
+set(object_distance_EXPORTED_TARGETS "")
+# create dummy targets for exported code generation targets to make life of users easier
+foreach(t ${object_distance_EXPORTED_TARGETS})
+  if(NOT TARGET ${t})
+    add_custom_target(${t})
+  endif()
+endforeach()
+
+set(depends "")
+foreach(depend ${depends})
+  string(REPLACE " " ";" depend_list ${depend})
+  # the package name of the dependency must be kept in a unique variable so that it is not overwritten in recursive calls
+  list(GET depend_list 0 object_distance_dep)
+  list(LENGTH depend_list count)
+  if(${count} EQUAL 1)
+    # simple dependencies must only be find_package()-ed once
+    if(NOT ${object_distance_dep}_FOUND)
+      find_package(${object_distance_dep} REQUIRED NO_MODULE)
+    endif()
+  else()
+    # dependencies with components must be find_package()-ed again
+    list(REMOVE_AT depend_list 0)
+    find_package(${object_distance_dep} REQUIRED NO_MODULE ${depend_list})
+  endif()
+  _list_append_unique(object_distance_INCLUDE_DIRS ${${object_distance_dep}_INCLUDE_DIRS})
+
+  # merge build configuration keywords with library names to correctly deduplicate
+  _pack_libraries_with_build_configuration(object_distance_LIBRARIES ${object_distance_LIBRARIES})
+  _pack_libraries_with_build_configuration(_libraries ${${object_distance_dep}_LIBRARIES})
+  _list_append_deduplicate(object_distance_LIBRARIES ${_libraries})
+  # undo build configuration keyword merging after deduplication
+  _unpack_libraries_with_build_configuration(object_distance_LIBRARIES ${object_distance_LIBRARIES})
+
+  _list_append_unique(object_distance_LIBRARY_DIRS ${${object_distance_dep}_LIBRARY_DIRS})
+  list(APPEND object_distance_EXPORTED_TARGETS ${${object_distance_dep}_EXPORTED_TARGETS})
+endforeach()
+
+set(pkg_cfg_extras "")
+foreach(extra ${pkg_cfg_extras})
+  if(NOT IS_ABSOLUTE ${extra})
+    set(extra ${object_distance_DIR}/${extra})
+  endif()
+  include(${extra})
+endforeach()
diff --git a/devel/share/roseus/ros/human_detection/manifest.l b/devel/share/roseus/ros/human_detection/manifest.l
new file mode 100644
index 0000000000000000000000000000000000000000..791f700b8fd097b7082713b1b642ef75b9485247
--- /dev/null
+++ b/devel/share/roseus/ros/human_detection/manifest.l
@@ -0,0 +1,9 @@
+;;
+;; DO NOT EDIT THIS FILE
+;;
+;; THIS FILE IS AUTOMATICALLY GENERATED
+;;  FROM /home/jerry/Documents/workspaces/ROS_human_detection/src/human_detection/package.xml (0.0.0)
+;; USING /opt/ros/kinetic/lib/python2.7/dist-packages/geneus/geneus_main.py /opt/ros/kinetic/share/geneus/package.xml (2.2.6)
+;;
+(ros::load-ros-package "std_msgs")
+(ros::load-ros-package "human_detection")
diff --git a/devel/share/roseus/ros/human_detection/msg/bounding_box.l b/devel/share/roseus/ros/human_detection/msg/bounding_box.l
new file mode 100644
index 0000000000000000000000000000000000000000..dc93c546a77154afdb1d3ef2c7e7b4b5105c59dd
--- /dev/null
+++ b/devel/share/roseus/ros/human_detection/msg/bounding_box.l
@@ -0,0 +1,99 @@
+;; Auto-generated. Do not edit!
+
+
+(when (boundp 'human_detection::bounding_box)
+  (if (not (find-package "HUMAN_DETECTION"))
+    (make-package "HUMAN_DETECTION"))
+  (shadow 'bounding_box (find-package "HUMAN_DETECTION")))
+(unless (find-package "HUMAN_DETECTION::BOUNDING_BOX")
+  (make-package "HUMAN_DETECTION::BOUNDING_BOX"))
+
+(in-package "ROS")
+;;//! \htmlinclude bounding_box.msg.html
+
+
+(defclass human_detection::bounding_box
+  :super ros::object
+  :slots (_xmin _xmax _ymin _ymax ))
+
+(defmethod human_detection::bounding_box
+  (:init
+   (&key
+    ((:xmin __xmin) 0)
+    ((:xmax __xmax) 0)
+    ((:ymin __ymin) 0)
+    ((:ymax __ymax) 0)
+    )
+   (send-super :init)
+   (setq _xmin (round __xmin))
+   (setq _xmax (round __xmax))
+   (setq _ymin (round __ymin))
+   (setq _ymax (round __ymax))
+   self)
+  (:xmin
+   (&optional __xmin)
+   (if __xmin (setq _xmin __xmin)) _xmin)
+  (:xmax
+   (&optional __xmax)
+   (if __xmax (setq _xmax __xmax)) _xmax)
+  (:ymin
+   (&optional __ymin)
+   (if __ymin (setq _ymin __ymin)) _ymin)
+  (:ymax
+   (&optional __ymax)
+   (if __ymax (setq _ymax __ymax)) _ymax)
+  (:serialization-length
+   ()
+   (+
+    ;; uint16 _xmin
+    2
+    ;; uint16 _xmax
+    2
+    ;; uint16 _ymin
+    2
+    ;; uint16 _ymax
+    2
+    ))
+  (:serialize
+   (&optional strm)
+   (let ((s (if strm strm
+              (make-string-output-stream (send self :serialization-length)))))
+     ;; uint16 _xmin
+       (write-word _xmin s)
+     ;; uint16 _xmax
+       (write-word _xmax s)
+     ;; uint16 _ymin
+       (write-word _ymin s)
+     ;; uint16 _ymax
+       (write-word _ymax s)
+     ;;
+     (if (null strm) (get-output-stream-string s))))
+  (:deserialize
+   (buf &optional (ptr- 0))
+   ;; uint16 _xmin
+     (setq _xmin (sys::peek buf ptr- :short)) (incf ptr- 2)
+   ;; uint16 _xmax
+     (setq _xmax (sys::peek buf ptr- :short)) (incf ptr- 2)
+   ;; uint16 _ymin
+     (setq _ymin (sys::peek buf ptr- :short)) (incf ptr- 2)
+   ;; uint16 _ymax
+     (setq _ymax (sys::peek buf ptr- :short)) (incf ptr- 2)
+   ;;
+   self)
+  )
+
+(setf (get human_detection::bounding_box :md5sum-) "0a18150eb9bc571abec460d2df647248")
+(setf (get human_detection::bounding_box :datatype-) "human_detection/bounding_box")
+(setf (get human_detection::bounding_box :definition-)
+      "uint16 xmin
+uint16 xmax
+uint16 ymin
+uint16 ymax
+
+")
+
+
+
+(provide :human_detection/bounding_box "0a18150eb9bc571abec460d2df647248")
+
+
diff --git a/src/get_obj_dist/.idea/get_obj_dist.iml b/src/get_obj_dist/.idea/get_obj_dist.iml
index f3a18e7be5bd2ca479f7ccbe60eeec36f891a7df..63e97cda7702287be14cc798750224b72053f2c4 100644
--- a/src/get_obj_dist/.idea/get_obj_dist.iml
+++ b/src/get_obj_dist/.idea/get_obj_dist.iml
@@ -2,6 +2,9 @@
 <module type="PYTHON_MODULE" version="4">
   <component name="NewModuleRootManager">
     <content url="file://$MODULE_DIR$" />
+    <content url="file:///opt/ros/kinetic/lib/python2.7/dist-packages">
+      <sourceFolder url="file:///opt/ros/kinetic/lib/python2.7/dist-packages" isTestSource="false" />
+    </content>
     <orderEntry type="jdk" jdkName="Python 2.7 (py2ROS)" jdkType="Python SDK" />
     <orderEntry type="sourceFolder" forTests="false" />
   </component>
diff --git a/src/get_obj_dist/src/object_to_distance.py b/src/get_obj_dist/src/object_to_distance.py
new file mode 100755
index 0000000000000000000000000000000000000000..1dbc6bd90715e6101ba18bed1a650719dfd557d0
--- /dev/null
+++ b/src/get_obj_dist/src/object_to_distance.py
@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+
+import numpy as np
+import sys
+import cv2
+
+import rospy
+import pyrealsense2 as rs2
+import message_filters
+from sensor_msgs.msg import Image, PointCloud2
+from cv_bridge import CvBridge, CvBridgeError
+
+
+class obj_dist:
+    def __init__(self):
+        # Initializing ROS Topics
+        self.bridge = CvBridge()
+        dist_pub = rospy.Publisher('/obj_to_dist', Image, queue_size=10)
+        self.human_sub = message_filters.Subscriber('/camera/color/image_raw', Image)
+        self.depth_sub = message_filters.Subscriber('/camera/depth_registered/points', PointCloud2)
+
+        ts = message_filters.TimeSynchronizer([self.human_sub, self.depth_sub], 10)
+        ts.registerCallback(self.callback)
+
+    def callback(self, Image, Depth):
+        print('wtf')
+
+def main(args):
+    _ = obj_dist()
+    rospy.init_node('obj_dist', anonymous=True)
+    rospy.spin()
+    cv2.destroyAllWindows()
+
+
+if __name__ == '__main__':
+    main(sys.argv)
+
diff --git a/src/get_obj_dist/src/rs_plc.py b/src/get_obj_dist/src/rs_plc.py
index ca13b0b9d0febba92bbec0cd64920b186dc7bfff..6a01833f5197132aa37dc83fd164f7090f71b6f3 100644
--- a/src/get_obj_dist/src/rs_plc.py
+++ b/src/get_obj_dist/src/rs_plc.py
@@ -1,7 +1,8 @@
 from datetime import datetime
 import pyrealsense2 as rs
 import numpy as np
-from open3d import *
+import open3d as o3d
+import time
 
 
 # Create a pipeline
@@ -19,9 +20,9 @@ profile = pipeline.start(config)
 
 # Streaming loop
 try:
-    vis = Visualizer()
+    vis = o3d.visualization.Visualizer()
     vis.create_window("Tests")
-    pcd = PointCloud()
+    pcd = o3d.geometry.PointCloud()
     while True:
         dt0 = datetime.now()
         vis.add_geometry(pcd)
@@ -35,13 +36,18 @@ try:
         pc = rs.pointcloud()
         pc.map_to(color)
         points = pc.calculate(depth)
-        vtx = np.asanyarray(points.get_vertices_2d())
-        pcd.points = Vector3dVector(vtx)
+        vtx = np.asanyarray(points.get_vertices())
+        print(vtx)
+        print(o3d.utility.Vector3dVector(vtx))
+        # pcd.points = o3d.utility.Vector3dVector(vtx)
         vis.update_geometry()
         vis.poll_events()
         vis.update_renderer()
         process_time = datetime.now() - dt0
         print("FPS = {0}".format(1/process_time.total_seconds()))
+        time.sleep(1)
+except KeyboardInterrupt:
+    print('Exiting')
 
 finally:
     pipeline.stop()
\ No newline at end of file
diff --git a/src/get_obj_dist/src/true_color.py b/src/get_obj_dist/src/true_color.py
new file mode 100644
index 0000000000000000000000000000000000000000..a8d60525eca1df797ab6e974fb237612e8eae83e
--- /dev/null
+++ b/src/get_obj_dist/src/true_color.py
@@ -0,0 +1,14 @@
+import cv2
+
+print(cv2.__version__)
+video = cv2.VideoCapture(1)
+
+while True:
+
+    ret, frame = video.read()
+
+    cv2.imshow('Object detector', frame)
+
+    # Press 'q' to quit
+    if cv2.waitKey(1) == ord('q'):
+        break
diff --git a/src/human_detection/CMakeLists.txt b/src/human_detection/CMakeLists.txt
index 306bf595814865bc1795138d0160ce8ee696feef..f8821b036bf1c03086b2f0ae65df3bf5e1248ce8 100644
--- a/src/human_detection/CMakeLists.txt
+++ b/src/human_detection/CMakeLists.txt
@@ -11,6 +11,7 @@ find_package(catkin REQUIRED COMPONENTS
   roslib
   rospy
   std_msgs
+  message_generation
 )
 
 ## System dependencies are found with CMake's conventions
@@ -47,11 +48,10 @@ find_package(catkin REQUIRED COMPONENTS
 ##   * add every package in MSG_DEP_SET to generate_messages(DEPENDENCIES ...)
 
 ## Generate messages in the 'msg' folder
-# add_message_files(
-#   FILES
-#   Message1.msg
-#   Message2.msg
-# )
+ add_message_files(
+   FILES
+   bounding_box.msg
+)
 
 ## Generate services in the 'srv' folder
 # add_service_files(
@@ -68,10 +68,10 @@ find_package(catkin REQUIRED COMPONENTS
 # )
 
 ## Generate added messages and services with any dependencies listed here
-# generate_messages(
-#   DEPENDENCIES
-#   std_msgs
-# )
+generate_messages(
+   DEPENDENCIES
+   std_msgs
+ )
 
 ################################################
 ## Declare ROS dynamic reconfigure parameters ##
@@ -105,7 +105,8 @@ find_package(catkin REQUIRED COMPONENTS
 catkin_package(
 #  INCLUDE_DIRS include
 #  LIBRARIES human_detection
-#  CATKIN_DEPENDS roslib rospy std_msgs
+   CATKIN_DEPENDS roslib rospy std_msgs message_runtime
+			
 #  DEPENDS system_lib
 )
 
diff --git a/src/human_detection/msg/bounding_box.msg b/src/human_detection/msg/bounding_box.msg
new file mode 100644
index 0000000000000000000000000000000000000000..abf447951edf3e5b9be6be42ccf3eef5929a9d4d
--- /dev/null
+++ b/src/human_detection/msg/bounding_box.msg
@@ -0,0 +1,4 @@
+uint16 xmin
+uint16 xmax
+uint16 ymin
+uint16 ymax
diff --git a/src/human_detection/package.xml b/src/human_detection/package.xml
index e8d0f8ad5653bf013e246a753941716c389c46b7..9ba4dd01f3dd28f61b9274dc2bb47f9951c51d42 100644
--- a/src/human_detection/package.xml
+++ b/src/human_detection/package.xml
@@ -52,9 +52,11 @@
   <build_depend>roslib</build_depend>
   <build_depend>rospy</build_depend>
   <build_depend>std_msgs</build_depend>
+  <build_depend>message_generation</build_depend>  
   <build_export_depend>roslib</build_export_depend>
   <build_export_depend>rospy</build_export_depend>
   <build_export_depend>std_msgs</build_export_depend>
+  <exec_depend>message_runtime</exec_depend>
   <exec_depend>roslib</exec_depend>
   <exec_depend>rospy</exec_depend>
   <exec_depend>std_msgs</exec_depend>
diff --git a/src/human_detection/src/analysis_tools/define.py b/src/human_detection/src/analysis_tools/define.py
index b1ca6efa9cc6628a0e3409d35815e516223e9b76..c841e6d21bb0b411e763e4e8fc624b4ad4f45ec6 100644
--- a/src/human_detection/src/analysis_tools/define.py
+++ b/src/human_detection/src/analysis_tools/define.py
@@ -12,4 +12,6 @@ font_scale = 0.75
 font_color = (255,255,255)
 line_type = 2
 run_time_list = []
-prediction_level_list = []
\ No newline at end of file
+prediction_level_list = []
+screen_width = 600
+screen_height = 480
\ No newline at end of file
diff --git a/src/human_detection/src/analysis_tools/define.pyc b/src/human_detection/src/analysis_tools/define.pyc
index d609b2d40fa31c1381a4f6f24ff3ec46c0080fc3..83dfaef6410ca36967ee2f71b3a310cc3aa32192 100644
Binary files a/src/human_detection/src/analysis_tools/define.pyc and b/src/human_detection/src/analysis_tools/define.pyc differ
diff --git a/src/human_detection/src/reference.py b/src/human_detection/src/reference.py
new file mode 100755
index 0000000000000000000000000000000000000000..69df44abacf50c2561f2d6c0b60122636eb44973
--- /dev/null
+++ b/src/human_detection/src/reference.py
@@ -0,0 +1,50 @@
+#!/usr/bin/env python
+from __future__ import print_function
+
+import sys
+import rospy
+import cv2
+from std_msgs.msg import String
+from sensor_msgs.msg import Image
+from cv_bridge import CvBridge, CvBridgeError
+
+class image_converter:
+
+  def __init__(self):
+    self.image_pub = rospy.Publisher("image_topic_2",Image, queue_size=10)
+
+    self.bridge = CvBridge()
+    self.image_sub = rospy.Subscriber("/camera/color/image_raw",Image,self.callback)
+
+  def callback(self,data):
+    try:
+      cv_image = self.bridge.imgmsg_to_cv2(data, "bgr8")
+      
+    except CvBridgeError as e:
+      print(e)
+
+    (rows,cols,channels) = cv_image.shape
+    if cols > 60 and rows > 60 :
+      cv2.circle(cv_image, (50,50), 10, 255)
+
+    cv2.imshow("Image window", cv_image)
+    cv2.waitKey(3)
+
+    try:
+      ret_val = self.bridge.cv2_to_imgmsg(cv_image, "bgr8")
+      ret_val.header = data.header
+      self.image_pub.publish(ret_val)
+    except CvBridgeError as e:
+      print(e)
+
+def main(args):
+  ic = image_converter()
+  rospy.init_node('image_converter', anonymous=True)
+  try:
+    rospy.spin()
+  except KeyboardInterrupt:
+    print("Shutting down")
+  cv2.destroyAllWindows()
+
+if __name__ == '__main__':
+    main(sys.argv)
\ No newline at end of file
diff --git a/src/human_detection/src/webcam.py b/src/human_detection/src/webcam.py
index 17d600d6ccdddba1ec976aa119ec1e9003c3f2d0..db485039367ecf26f4d708ca643bb3c016456f29 100755
--- a/src/human_detection/src/webcam.py
+++ b/src/human_detection/src/webcam.py
@@ -1,16 +1,18 @@
 #!/usr/bin/env python
 
-# For Performance timing, import time.
-from analysis_tools.data_grapher import *
-from analysis_tools.define import *
+
 import time
 import sys
 import os
 import tensorflow as tf
-
-import numpy as np
+sys.path.append('/home/jerry/Documents/workspaces/ROS_human_detection/src/human_detection')
+# import numpy as np
 import rospy
-# from std_msgs.msg import string
+
+# For performance analysis timing, import time.
+from analysis_tools.data_grapher import *
+from analysis_tools.define import *
+from human_detection.msg import bounding_box
 from sensor_msgs.msg import Image
 from cv_bridge import CvBridge, CvBridgeError
 
@@ -26,16 +28,12 @@ MODEL_NAME = 'ssd_mobilenet_v1_coco_2017_11_17'
 PATH_TO_CKPT = os.path.join(CWD_PATH, MODEL_NAME, 'frozen_inference_graph.pb')
 PATH_TO_LABELS = os.path.join(CWD_PATH + '/data', LABEL_MAPS[0])
 
-
-
-
 # Load the label map.
 label_map = label_map_util.load_labelmap(PATH_TO_LABELS)
 categories = label_map_util.convert_label_map_to_categories(
     label_map, max_num_classes=NUM_CLASSES, use_display_name=True)
 category_index = label_map_util.create_category_index(categories)
 
-
 # Load the Tensorflow model into memory.
 detection_graph = tf.Graph()
 with detection_graph.as_default():
@@ -47,7 +45,6 @@ with detection_graph.as_default():
 
     sess = tf.compat.v1.Session(graph=detection_graph)
 
-
 # Define input and output tensors (i.e. data) for the object detection classifier
 
 # Input tensor is the image
@@ -65,13 +62,13 @@ detection_classes = detection_graph.get_tensor_by_name('detection_classes:0')
 # Number of objects detected
 num_detections = detection_graph.get_tensor_by_name('num_detections:0')
 
-
 # time_origin = time.time()
 class human_detector:
     def __init__(self):
         self.bridge = CvBridge()
         self.image_pub = rospy.Publisher(
-            "human_detected_image", Image, queue_size=10)
+            "/human_detected_image/image", Image, queue_size=10)
+        self.bbx_pub = rospy.Publisher('/human_detected_image/bounding_box', bounding_box, queue_size=10)
         self.image_sub = rospy.Subscriber(
             "/camera/color/image_raw", Image, self.callback)
 
@@ -81,6 +78,7 @@ class human_detector:
             cv_image = self.bridge.imgmsg_to_cv2(data, "bgr8")
         except CvBridgeError as e:
             print(e)
+            return
 
         frame_expanded = np.expand_dims(cv_image, axis=0)
 
@@ -111,39 +109,52 @@ class human_detector:
             min_score_thresh=0.60)
 
         # Calculate frame time
-        t1 = time.time()
-        run_time = t1-t0
-        if run_time < 1:
-            run_time_list.append(run_time)
-            if len(run_time_list) > 10:
-                del run_time_list[0]
-        
-        if len(run_time_list) > 0:
-            avg_run_time = round(sum(run_time_list)/len(run_time_list)*1000, 1)
-            cv2.putText(cv_image, 'Run Time: {}ms'.format(avg_run_time), 
-            text_position,
-            font,
-            font_scale,
-            font_color,
-            line_type)
+        # t1 = time.time()
+        # run_time = t1 - t0
+        # if run_time < 1:
+        #     run_time_list.append(run_time)
+        #     if len(run_time_list) > 10:
+        #         del run_time_list[0]
 
+        if len(run_time_list) > 0:
+            avg_run_time = round(sum(run_time_list) / len(run_time_list) * 1000, 1)
+            cv2.putText(cv_image, 'Run Time: {}ms'.format(avg_run_time),
+                        text_position,
+                        font,
+                        font_scale,
+                        font_color,
+                        line_type)
+        counter = 0
+        for score in scores[0]:
+            if score > 0.6:
+                coordinates = bounding_box()
+                coordinates.ymin = int(boxes[0, counter, 0] * screen_height)
+                coordinates.xmin = int(boxes[0, counter, 1] * screen_width)
+                coordinates.ymax = int(boxes[0, counter, 2] * screen_height)
+                coordinates.xmax = int(boxes[0, counter, 3] * screen_width)
+                self.bbx_pub.publish(coordinates)
+            counter += 1
 
         try:
-            self.image_pub.publish(self.bridge.cv2_to_imgmsg(cv_image, "bgr8"))
+            cvt_msg = self.bridge.cv2_to_imgmsg(cv_image, "bgr8")
+            cvt_msg.header = data.header
+            self.image_pub.publish(cvt_msg)
         except CvBridgeError as e:
             print(e)
+ 
 
         # Append Accuracy
-        if scores[0][0] > 0.01:
-            prediction_level_list.append(scores[0][0])
+        # if scores[0][0] > 0.01:
+        #     prediction_level_list.append(scores[0][0])
 
 
 def main(args):
     print(args)
-    hd = human_detector()
+    _ = human_detector()
     rospy.init_node('human_detector', anonymous=True)
     rospy.spin()
-    graph_average_percentage(prediction_level_list)
+    # graph_average_percentage(prediction_level_list)
+
 
 if __name__ == '__main__':
     main(sys.argv)