* initial commit

Author: jingweiz

CMakeLists.txt

@@ -0,0 +1,187 @@
+cmake_minimum_required(VERSION 2.8.3)
+project(renderer)
+
+## Compile as C++11, supported in ROS Kinetic and newer
+# add_compile_options(-std=c++11)
+
+## Find catkin macros and libraries
+## if COMPONENTS list like find_package(catkin REQUIRED COMPONENTS xyz)
+## is used, also find other catkin packages
+find_package(catkin REQUIRED COMPONENTS
+  pcl_conversions
+  pcl_ros
+  roscpp
+  rospy
+  sensor_msgs
+  std_msgs
+  std_srvs
+  cv_bridge
+  image_transport
+  message_generation
+)
+
+## System dependencies are found with CMake's conventions
+# find_package(Boost REQUIRED COMPONENTS system)
+
+
+## Uncomment this if the package has a setup.py. This macro ensures
+## modules and global scripts declared therein get installed
+## See http://ros.org/doc/api/catkin/html/user_guide/setup_dot_py.html
+# catkin_python_setup()
+
+################################################
+## Declare ROS messages, services and actions ##
+################################################
+
+## To declare and build messages, services or actions from within this
+## package, follow these steps:
+## * Let MSG_DEP_SET be the set of packages whose message types you use in
+##   your messages/services/actions (e.g. std_msgs, actionlib_msgs, ...).
+## * In the file package.xml:
+##   * add a build_depend tag for "message_generation"
+##   * add a build_depend and a run_depend tag for each package in MSG_DEP_SET
+##   * If MSG_DEP_SET isn't empty the following dependency has been pulled in
+##     but can be declared for certainty nonetheless:
+##     * add a run_depend tag for "message_runtime"
+## * In this file (CMakeLists.txt):
+##   * add "message_generation" and every package in MSG_DEP_SET to
+##     find_package(catkin REQUIRED COMPONENTS ...)
+##   * add "message_runtime" and every package in MSG_DEP_SET to
+##     catkin_package(CATKIN_DEPENDS ...)
+##   * uncomment the add_*_files sections below as needed
+##     and list every .msg/.srv/.action file to be processed
+##   * uncomment the generate_messages entry below
+##   * 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
+# )
+
+## Generate services in the 'srv' folder
+add_service_files(
+    FILES
+    Preprocess.srv
+    Render.srv
+)
+
+## Generate actions in the 'action' folder
+# add_action_files(
+#   FILES
+#   Action1.action
+#   Action2.action
+# )
+
+## Generate added messages and services with any dependencies listed here
+generate_messages(
+    DEPENDENCIES
+    std_msgs
+    sensor_msgs
+)
+
+################################################
+## Declare ROS dynamic reconfigure parameters ##
+################################################
+
+## To declare and build dynamic reconfigure parameters within this
+## package, follow these steps:
+## * In the file package.xml:
+##   * add a build_depend and a run_depend tag for "dynamic_reconfigure"
+## * In this file (CMakeLists.txt):
+##   * add "dynamic_reconfigure" to
+##     find_package(catkin REQUIRED COMPONENTS ...)
+##   * uncomment the "generate_dynamic_reconfigure_options" section below
+##     and list every .cfg file to be processed
+
+## Generate dynamic reconfigure parameters in the 'cfg' folder
+# generate_dynamic_reconfigure_options(
+#   cfg/DynReconf1.cfg
+#   cfg/DynReconf2.cfg
+# )
+
+###################################
+## catkin specific configuration ##
+###################################
+## The catkin_package macro generates cmake config files for your package
+## Declare things to be passed to dependent projects
+## INCLUDE_DIRS: uncomment this if your package contains header files
+## LIBRARIES: libraries you create in this project that dependent projects also need
+## CATKIN_DEPENDS: catkin_packages dependent projects also need
+## DEPENDS: system dependencies of this project that dependent projects also need
+catkin_package(
+#  INCLUDE_DIRS include
+#  LIBRARIES renderer
+#  CATKIN_DEPENDS message_runtime pcl_conversions pcl_ros rospy sensor_msgs std_msgs std_srvs cv_bridge
+#  DEPENDS system_lib
+)
+
+###########
+## Build ##
+###########
+
+include(CheckCXXCompilerFlag)
+CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)
+CHECK_CXX_COMPILER_FLAG("-std=c++0x" COMPILER_SUPPORTS_CXX0X)
+if(COMPILER_SUPPORTS_CXX11)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+elseif(COMPILER_SUPPORTS_CXX0X)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
+else()
+        message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.")
+endif()
+
+include_directories(include)
+include_directories(${catkin_INCLUDE_DIRS})
+
+add_executable(renderer_node node/renderer_node.cpp src/renderer.cpp)
+target_link_libraries(renderer_node ${catkin_LIBRARIES})
+
+#############
+## Install ##
+#############
+
+# all install targets should use catkin DESTINATION variables
+# See http://ros.org/doc/api/catkin/html/adv_user_guide/variables.html
+
+## Mark executable scripts (Python etc.) for installation
+## in contrast to setup.py, you can choose the destination
+# install(PROGRAMS
+#   scripts/my_python_script
+#   DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
+# )
+
+## Mark executables and/or libraries for installation
+# install(TARGETS ${PROJECT_NAME} ${PROJECT_NAME}_node
+#   ARCHIVE DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
+#   LIBRARY DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
+#   RUNTIME DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
+# )
+
+## Mark cpp header files for installation
+# install(DIRECTORY include/${PROJECT_NAME}/
+#   DESTINATION ${CATKIN_PACKAGE_INCLUDE_DESTINATION}
+#   FILES_MATCHING PATTERN "*.h"
+#   PATTERN ".svn" EXCLUDE
+# )
+
+## Mark other files for installation (e.g. launch and bag files, etc.)
+# install(FILES
+#   # myfile1
+#   # myfile2
+#   DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION}
+# )
+
+#############
+## Testing ##
+#############
+
+## Add gtest based cpp test target and link libraries
+# catkin_add_gtest(${PROJECT_NAME}-test test/test_renderer.cpp)
+# if(TARGET ${PROJECT_NAME}-test)
+#   target_link_libraries(${PROJECT_NAME}-test ${PROJECT_NAME})
+# endif()
+
+## Add folders to be run by python nosetests
+# catkin_add_nosetests(test)

LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Jingwei Zhang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,69 @@
+# **renderer**
+_a ROS package to turn your point clouds into a simulator for training Deep Reinforcement Learning agents_
+
+(paired w/ files to interface w/ DRL agents, e.g. [pytorch-rl](https://github.com/jingweiz/pytorch-rl))
+*******
+
+
+## What is this?
+> This repo contains a ROS package that can be used to turn your point cloud (e.g. `.pcd`'s) into a simulator, where your agent can wonder around. The `/render` service will render **RGB** or **depth** images from the current pose of your agent. Thus this repo can be helpful if you want to train some DRL agents (e.g. [pytorch-rl](https://github.com/jingweiz/pytorch-rl)) out of the point cloud data you collected, for example, of your office. This repo is developed w/ the help of [@onlytailei](https://github.com/onlytailei).
+
+![rviz](/assets/rviz.png)
+
+*******
+
+
+## Tested system configurations:
+- Ubuntu 16.04
+- [ROS Kinetic](http://wiki.ros.org/kinetic/Installation/Ubuntu)
+*******
+
+
+## How to run:
+* Compile the `renderer` package:
+> * clone the package into `YOUR_ROS_WORKSPACE_DIRECTORY/src/`
+> * `catkin_make` in `YOUR_ROS_WORKSPACE_DIRECTORY`
+* Launch node:
+> `roslaunch renderer renderer.launch`
+* Call service (`action_ind={3`(reset)`,0`(go straight)`,1`(turn left)`,2`(turn right)`}`):
+> `rosservice call /render action_ind`
+*******
+
+
+## How to pair w/ [pytorch-rl](https://github.com/jingweiz/pytorch-rl)?
+* Turn off the `rviz` visualizations in `./launch/renderer.launch` (cos we don't want to slow down the expensive DRL trainings :P):
+> * `line2-3`: comment off to turn off `rviz`
+> * `line5`: set `display` to `false`
+* Copy the generated interfacing files from `YOUR_ROS_WORKSPACE_DIRECTORY` into `pytorch-rl`:
+> ```cp -r YOUR_ROS_WORKSPACE_DIRECTORY/devel/lib/python.../dist-packages/renderer YOUR_pytorch-rl_DIRECTORY/```
+* Copy the provided env wrapper from `YOUR_ROS_WORKSPACE_DIRECTORY` into `pytorch-rl`:
+> ```cp YOUR_ROS_WORKSPACE_DIRECTORY/envs/rendererEnv.py YOUR_pytorch-rl_DIRECTORY/core/envs/```
+*******
+
+
+## About the point clouds:
+The `pcd/office.pcd` & `pcd/chair.pcd` are provided by my awesome colleagues `Tim Caselitz (@caselitz)` and `Michael Krawez`.
+If you want to use your own point clouds, you need to:
+> * put those `.pcd`'s into `./data/`
+> * modify the magic numbers in `line522-527` & `line549-554` in `./src/renderer.cpp` to align the clouds w/ the axis
+> * finally `rosservice call /preprocess` to save the aligned clouds into `./pcd/`
+
+*******
+
+
+## The following paper might be interesting to take a look:)
+> [VR Goggles for Robots: Real-to-sim Domain Adaptation for Visual Control](https://arxiv.org/abs/1802.00265): This paper deals with the _**reality gap**_ from a novel perspective, targeting transferring Deep Reinforcement Learning (DRL) policies learned in simulated environments to the real-world domain for visual control tasks. Instead of adopting the common solutions to the problem by increasing the visual fidelity of synthetic images output from simulators during the training phase, this paper seeks to tackle the problem by translating the real-world image streams back to the synthetic domain during the deployment phase, to _**make the robot feel at home**_.
+We propose this as a lightweight, flexible, and efficient solution for visual control, as 1) no extra transfer steps are required during the expensive training of DRL agents in simulation; 2) the trained DRL agents will not be constrained to being deployable in only one specific real-world environment; 3) the policy training and the transfer operations are decoupled, and can be conducted in parallel.
+Besides this, we propose a conceptually simple yet very effective _**shift loss**_ to constrain the consistency between subsequent frames, eliminating the need for optical flow.
+We validate the _**shift loss**_ for _**artistic style transfer for videos**_ and _**domain adaptation**_, and validate our visual control approach in real-world robot experiments. A video of our results is available at:
+\url{https://goo.gl/b1xz1s}.
+.
+
+```
+@article{zhang2018vr,
+  title={Vr goggles for robots: Real-to-sim domain adaptation for visual control},
+  author={Zhang, Jingwei and Tai, Lei and Xiong, Yufeng and Liu, Ming and Boedecker, Joschka and Burgard, Wolfram},
+  journal={arXiv preprint arXiv:1802.00265},
+  year={2018}
+}
+```

assets/rviz.png

@@ -0,0 +1,96 @@
+from __future__ import absolute_import
+from __future__ import division
+
+import numpy as np
+from copy import deepcopy
+from gym.spaces.box import Box
+import inspect
+import os, subprocess
+import cv2
+import time
+import timeit
+import rospy, rosgraph
+from sensor_msgs.msg import Image
+from cv_bridge import CvBridge
+from utils.helpers import preprocessAtari, rgb2gray, rgb2y, scale, center_crop_rgb, center_crop_depth
+from core.env import Env
+import math
+from PIL import Image
+import matplotlib.pyplot as plt
+
+import torch
+import torchvision
+from torchvision import datasets, models, transforms
+
+class RendererEnv(Env):
+    def __init__(self, args, env_ind=0):
+        super(RendererEnv, self).__init__(args, env_ind)
+        self.env_ind = env_ind
+        self.enable_continuous = args.enable_continuous
+
+        # TODO: use this for training in docker on remotes
+        # os.environ["ROS_MASTER_URI"] = "http://rosimage"+str(self.env_ind)+":11311"
+        # TODO: use this for local test
+        os.environ["ROS_MASTER_URI"] = "http://localhost:11311"
+
+        time.sleep(10)
+        self.root_dir = args.root_dir
+
+        try:
+            from renderer.srv import Render
+        except ImportError as e: self.logger.warning("WARNING: renderer not found")
+
+        # set up service
+        self.render_srv = rospy.ServiceProxy('/render', Render)
+
+        self.hei_state = args.hei_state
+        self.wid_state = args.wid_state
+        self.preprocess_mode = args.preprocess_mode
+        self.img_encoding_type = args.img_encoding_type
+
+        self.bridge = CvBridge()
+
+    def __del__(self):
+        self.render_service.close()
+
+    @property
+    def action_dim(self):
+        # NOTE: in /render service,
+        # NOTE: 0: go_straight | 1 : turn_left | 2: turn_right
+        # NOTE: 3: reset the game
+        return 3
+
+    @property
+    def state_shape(self):
+        return (self.hei_state, self.wid_state)
+
+    def _preprocessState(self, state):    # called before _preprocessState in A3CSingleProcess
+        img = self.bridge.imgmsg_to_cv2(state, self.img_encoding_type)
+        # # visualize img
+        # plt.figure(); plt.imshow(img); plt.show(); raw_input()
+
+        if self.preprocess_mode == 4:   # for rgb images: do not convert to grayscale
+            img = 2 * (scale(img, self.hei_state, self.wid_state) / 255. - 0.5)  # (90, 160, 3) (-1, 1)
+            img = np.transpose(img, (2, 0, 1))   # (3, 90, 160)
+
+        return img
+
+    def step(self, exp_action):
+        # # in test phase, for synchronization
+        # time.sleep(0.1)
+        try:
+            # TODO: use this for training in docker on remotes
+            # os.environ["ROS_MASTER_URI"] = "http://rosimage"+str(self.env_ind)+":11311"
+            # TODO: use this for local test
+            os.environ["ROS_MASTER_URI"] = "http://localhost:11311"
+
+            render_res = self.render_srv(exp_action)
+            self.exp_state1 = render_res.color
+            self.exp_reward = render_res.reward
+            self.exp_terminal1 = render_res.terminal
+        except rospy.ServiceException, e:
+            print("Service call failed during step: %s" %e)
+        return self._get_experience()
+
+    def reset(self):
+        return self.step(self.action_dim)