File Organize

devel/.built_by

-catkin_make
\ No newline at end of file

devel/.catkin

-/home/superkuo/Documents/workspace/cv_practice_ws/src;/home/jerry/Documents/workspaces/ROS_human_detection/src
\ No newline at end of file

devel/.rosinstall

-- setup-file:
-    local-name: /home/jerry/Documents/workspaces/ROS_human_detection/devel/setup.sh

devel/_setup_util.py

-#!/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)

devel/env.sh

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

devel/include/human_detection/bounding_box.h

-// 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

devel/lib/pkgconfig/cv2_cvter.pc

-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: 

devel/lib/pkgconfig/get_obj_dist.pc

-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: 

devel/lib/pkgconfig/human_detection.pc

-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

devel/lib/pkgconfig/measure_obj_dist.pc

-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: 

devel/lib/pkgconfig/obj_dist.pc

-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: 

devel/lib/pkgconfig/object_distance.pc

-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: 

devel/lib/python3/dist-packages/human_detection/msg/__init__.py

-from ._bounding_box import *

devel/lib/python3/dist-packages/human_detection/msg/_bounding_box.py

-# 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

devel/local_setup.bash

-#!/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

devel/local_setup.sh

-#!/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