├── .gitattributes ├── scripts └── shape_completion_server │ ├── trained_models │ ├── __init__.py │ ├── README.md │ ├── load_trained_model.sh │ └── depth_y17_m05_d26_h14_m22_s35_bare_keras_v2.tar.gz │ ├── __init__.py │ └── mesh_completion_server.py ├── .gitignore ├── srv └── SetCNNType.srv ├── set_env.sh ├── setup.py ├── package.xml ├── README.md └── CMakeLists.txt /.gitattributes: -------------------------------------------------------------------------------- 1 | *.tar.gz filter=lfs diff=lfs merge=lfs -text 2 | -------------------------------------------------------------------------------- /scripts/shape_completion_server/trained_models/__init__.py: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /scripts/shape_completion_server/trained_models/README.md: -------------------------------------------------------------------------------- 1 | Place trained models here. -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | *.*~ 2 | *.h5 3 | *.pyc 4 | scripts/shape_completion_server/trained_models/* -------------------------------------------------------------------------------- /srv/SetCNNType.srv: -------------------------------------------------------------------------------- 1 | #Request 2 | string cnn_name 3 | --- 4 | #Response 5 | bool success -------------------------------------------------------------------------------- /scripts/shape_completion_server/__init__.py: -------------------------------------------------------------------------------- 1 | from mesh_completion_server import MeshCompletionServer 2 | -------------------------------------------------------------------------------- /scripts/shape_completion_server/trained_models/load_trained_model.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | tar -xvf depth_y17_m05_d26_h14_m22_s35_bare_keras_v2.tar.gz 4 | touch depth_y17_m05_d26_h14_m22_s35_bare_keras_v2/__init__.py 5 | -------------------------------------------------------------------------------- /set_env.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # set ROS env variables 4 | export ROS_MASTER_URI=http://skye.local:11311 5 | echo ROS_MASTER_URI $ROS_MASTER_URI 6 | 7 | export ROS_HOSTNAME=$(hostname -f).local 8 | echo ROS_HOSTNAME $ROS_HOSTNAME 9 | -------------------------------------------------------------------------------- /scripts/shape_completion_server/trained_models/depth_y17_m05_d26_h14_m22_s35_bare_keras_v2.tar.gz: -------------------------------------------------------------------------------- 1 | version https://git-lfs.github.com/spec/v1 2 | oid sha256:b8f16e77a990560ebbef01a8b476450c2bf29cf91c324e2b0b2239e7e945f3c7 3 | size 1101490205 4 | -------------------------------------------------------------------------------- /setup.py: -------------------------------------------------------------------------------- 1 | ## ! DO NOT MANUALLY INVOKE THIS setup.py, USE CATKIN INSTEAD 2 | 3 | from setuptools import setup 4 | from setuptools import setup, find_packages 5 | from catkin_pkg.python_setup import generate_distutils_setup 6 | 7 | 8 | 9 | d = generate_distutils_setup() 10 | 11 | d['name'] = "shape_completion_server" 12 | d['description'] = "shape completion server" 13 | d['packages'] = ['shape_completion_server'] 14 | d['package_dir'] = {'': 'scripts'} 15 | 16 | 17 | 18 | setup(**d) 19 | 20 | -------------------------------------------------------------------------------- /package.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | pc_object_completion_cnn 4 | 0.0.0 5 | The pc_object_completion_cnn package. Contains the ROS action server for running shape completion 6 | 7 | 8 | 9 | 10 | jvarley 11 | 12 | 13 | 14 | 15 | 16 | MIT 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | catkin 43 | 44 | message_generation 45 | 46 | message_runtime 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # pc_object_completion_cnn 2 | ROS node for shape completion. This node runs an action server to take in pointclouds representing partial views of an object, and returning a completed mesh of the object. 3 | 4 | This is the maintained code base for the shape completion CNN from the IROS 2017 paper "Shape Completion Enabled Robotic Grasping" 5 | ``` 6 | @inproceedings{varley2017shape, 7 | title={Shape Completion Enabled Robotic Grasping}, 8 | author={Varley, Jacob and DeChant, Chad and Richardson, Adam and Nair, Avinash and Ruales, Joaqu{\'\i}n and Allen, Peter}, 9 | booktitle={Intelligent Robots and Systems (IROS), 2017 IEEE/RSJ International Conference on}, 10 | year={2017}, 11 | organization={IEEE} 12 | } 13 | ``` 14 | ## Dependencies 15 | This has been tested on ubuntu 14.04 and ROS Indigo and ubuntu 16.04 and ROS Kinetic. You will need to first setup Keras with a tensorflow backend. Setup instructions can be found here: https://github.com/fchollet/keras/ 16 | 17 | This repos is best run as part of: https://github.com/CURG/pc_pipeline_launch which should be setup first. Once the pc_pipeline is setup, this node offers a drop in replacement for pc_object_completion_partial. 18 | 19 | ## Other Smaller Dependencies 20 | ``` 21 | git clone git@github.com:CURG/binvox-rw-py.git 22 | git clone git@github.com:ShapeCompletion3D/python-pcl.git 23 | git clone git@github.com:CURG/Curvox.git 24 | git clone git@github.com:CURG/Mesh_Reconstruction.git 25 | ``` 26 | 27 | binvox_rw: python utility library to read and write voxel grids to run length encoded binvox files 28 | 29 | python-pcl: python utility library to read and write pointclouds to .pcd files 30 | 31 | Curvox: python mesh/pointcloud utility library mostly for marshalling ros mesh and pointcloud messages into ply and pcd files 32 | 33 | Mesh_Reconstruction: Code from IROS 2017 "Shape Completion Enabled Robotic Grasping" paper. This code takes the 40^3 voxel grid output from the CNN and combines it with the high resolution observed pointcloud directly captured from the depth sensor. This way the visible portions of the completions are nicely detailed. 34 | 35 | ## Setup 36 | ``` 37 | cd ~ 38 | mkdir -p ~/cnn_completion_ws/src 39 | cd ~/cnn_completion_ws/src 40 | git clone git@github.com:CURG/pc_pipeline_msgs.git 41 | git clone git@github.com:CURG/pc_object_completion_cnn.git 42 | 43 | cd ~/cnn_completion_ws/src/pc_object_completion_cnn/scripts/shape_completion_server/trained_models 44 | ./load_trained_model.sh 45 | 46 | cd ~/cnn_completion_ws 47 | source /opt/ros/indigo/setup.bash 48 | catkin_make 49 | ``` 50 | 51 | You will also need to modify set_env.sh to correctly set where to reach your ROS core. 52 | 53 | ## Running 54 | ``` 55 | cd ~/cnn_completion_ws/ 56 | source devel/setup.bash 57 | cd ~/cnn_completion_ws/src/pc_object_completion_cnn 58 | source set_env.sh 59 | rosrun pc_object_completion_cnn mesh_completion_server.py 60 | ``` 61 | -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 2.8.3) 2 | project(pc_object_completion_cnn) 3 | 4 | ## Find catkin macros and libraries 5 | ## if COMPONENTS list like find_package(catkin REQUIRED COMPONENTS xyz) 6 | ## is used, also find other catkin packages 7 | find_package(catkin REQUIRED COMPONENTS std_msgs rospy message_generation actionlib actionlib_msgs) 8 | 9 | ## System dependencies are found with CMake's conventions 10 | # find_package(Boost REQUIRED COMPONENTS system) 11 | 12 | 13 | ## Uncomment this if the package has a setup.py. This macro ensures 14 | ## modules and global scripts declared therein get installed 15 | ## See http://ros.org/doc/api/catkin/html/user_guide/setup_dot_py.html 16 | catkin_python_setup() 17 | 18 | ################################################ 19 | ## Declare ROS messages, services and actions ## 20 | ################################################ 21 | 22 | ## To declare and build messages, services or actions from within this 23 | ## package, follow these steps: 24 | ## * Let MSG_DEP_SET be the set of packages whose message types you use in 25 | ## your messages/services/actions (e.g. std_msgs, actionlib_msgs, ...). 26 | ## * In the file package.xml: 27 | ## * add a build_depend tag for "message_generation" 28 | ## * add a build_depend and a run_depend tag for each package in MSG_DEP_SET 29 | ## * If MSG_DEP_SET isn't empty the following dependency has been pulled in 30 | ## but can be declared for certainty nonetheless: 31 | ## * add a run_depend tag for "message_runtime" 32 | ## * In this file (CMakeLists.txt): 33 | ## * add "message_generation" and every package in MSG_DEP_SET to 34 | ## find_package(catkin REQUIRED COMPONENTS ...) 35 | ## * add "message_runtime" and every package in MSG_DEP_SET to 36 | ## catkin_package(CATKIN_DEPENDS ...) 37 | ## * uncomment the add_*_files sections below as needed 38 | ## and list every .msg/.srv/.action file to be processed 39 | ## * uncomment the generate_messages entry below 40 | ## * add every package in MSG_DEP_SET to generate_messages(DEPENDENCIES ...) 41 | 42 | ## Generate messages in the 'msg' folder 43 | # add_message_files( 44 | # FILES 45 | # Message1.msg 46 | # Message2.msg 47 | # ) 48 | 49 | ## Generate services in the 'srv' folder 50 | add_service_files( 51 | FILES 52 | SetCNNType.srv 53 | ) 54 | 55 | ## Generate actions in the 'action' folder 56 | # add_action_files( 57 | # FILES 58 | # CompleteMesh.action 59 | # ) 60 | 61 | ## Generate added messages and services with any dependencies listed here 62 | generate_messages( 63 | DEPENDENCIES 64 | std_msgs # Or other packages containing msgs 65 | ) 66 | 67 | ################################################ 68 | ## Declare ROS dynamic reconfigure parameters ## 69 | ################################################ 70 | 71 | ## To declare and build dynamic reconfigure parameters within this 72 | ## package, follow these steps: 73 | ## * In the file package.xml: 74 | ## * add a build_depend and a run_depend tag for "dynamic_reconfigure" 75 | ## * In this file (CMakeLists.txt): 76 | ## * add "dynamic_reconfigure" to 77 | ## find_package(catkin REQUIRED COMPONENTS ...) 78 | ## * uncomment the "generate_dynamic_reconfigure_options" section below 79 | ## and list every .cfg file to be processed 80 | 81 | ## Generate dynamic reconfigure parameters in the 'cfg' folder 82 | # generate_dynamic_reconfigure_options( 83 | # cfg/DynReconf1.cfg 84 | # cfg/DynReconf2.cfg 85 | # ) 86 | 87 | ################################### 88 | ## catkin specific configuration ## 89 | ################################### 90 | ## The catkin_package macro generates cmake config files for your package 91 | ## Declare things to be passed to dependent projects 92 | ## INCLUDE_DIRS: uncomment this if you package contains header files 93 | ## LIBRARIES: libraries you create in this project that dependent projects also need 94 | ## CATKIN_DEPENDS: catkin_packages dependent projects also need 95 | ## DEPENDS: system dependencies of this project that dependent projects also need 96 | catkin_package( 97 | # INCLUDE_DIRS include 98 | # LIBRARIES shape_completion_server 99 | # CATKIN_DEPENDS other_catkin_pkg 100 | # DEPENDS system_lib 101 | ) 102 | 103 | ########### 104 | ## Build ## 105 | ########### 106 | 107 | ## Specify additional locations of header files 108 | ## Your package locations should be listed before other locations 109 | # include_directories(include) 110 | 111 | ## Declare a C++ library 112 | # add_library(shape_completion_server 113 | # src/${PROJECT_NAME}/shape_completion_server.cpp 114 | # ) 115 | 116 | ## Add cmake target dependencies of the library 117 | ## as an example, code may need to be generated before libraries 118 | ## either from message generation or dynamic reconfigure 119 | # add_dependencies(shape_completion_server ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS}) 120 | 121 | ## Declare a C++ executable 122 | # add_executable(shape_completion_server_node src/shape_completion_server_node.cpp) 123 | 124 | ## Add cmake target dependencies of the executable 125 | ## same as for the library above 126 | # add_dependencies(shape_completion_server_node ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS}) 127 | 128 | ## Specify libraries to link a library or executable target against 129 | # target_link_libraries(shape_completion_server_node 130 | # ${catkin_LIBRARIES} 131 | # ) 132 | 133 | ############# 134 | ## Install ## 135 | ############# 136 | 137 | # all install targets should use catkin DESTINATION variables 138 | # See http://ros.org/doc/api/catkin/html/adv_user_guide/variables.html 139 | 140 | ## Mark executable scripts (Python etc.) for installation 141 | ## in contrast to setup.py, you can choose the destination 142 | # install(PROGRAMS 143 | # scripts/my_python_script 144 | # DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION} 145 | # ) 146 | 147 | ## Mark executables and/or libraries for installation 148 | # install(TARGETS shape_completion_server shape_completion_server_node 149 | # ARCHIVE DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION} 150 | # LIBRARY DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION} 151 | # RUNTIME DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION} 152 | # ) 153 | 154 | ## Mark cpp header files for installation 155 | # install(DIRECTORY include/${PROJECT_NAME}/ 156 | # DESTINATION ${CATKIN_PACKAGE_INCLUDE_DESTINATION} 157 | # FILES_MATCHING PATTERN "*.h" 158 | # PATTERN ".svn" EXCLUDE 159 | # ) 160 | 161 | ## Mark other files for installation (e.g. launch and bag files, etc.) 162 | # install(FILES 163 | # # myfile1 164 | # # myfile2 165 | # DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION} 166 | # ) 167 | 168 | ############# 169 | ## Testing ## 170 | ############# 171 | 172 | ## Add gtest based cpp test target and link libraries 173 | # catkin_add_gtest(${PROJECT_NAME}-test test/test_shape_completion_server.cpp) 174 | # if(TARGET ${PROJECT_NAME}-test) 175 | # target_link_libraries(${PROJECT_NAME}-test ${PROJECT_NAME}) 176 | # endif() 177 | 178 | ## Add folders to be run by python nosetests 179 | # catkin_add_nosetests(test) 180 | -------------------------------------------------------------------------------- /scripts/shape_completion_server/mesh_completion_server.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | 3 | import importlib 4 | import numpy as np 5 | import subprocess 6 | import tempfile 7 | import argparse 8 | import os 9 | 10 | import pcl 11 | import binvox_rw 12 | import plyfile 13 | 14 | import rospkg 15 | import actionlib 16 | import rospy 17 | 18 | import pc_pipeline_msgs.msg 19 | import pc_object_completion_cnn.srv 20 | from sensor_msgs import point_cloud2 21 | 22 | import curvox.pc_vox_utils 23 | import curvox.ros_mesh_conversions 24 | import curvox.cloud_conversions 25 | import curvox.cloud_transformations 26 | 27 | 28 | class MeshCompletionServer(object): 29 | def __init__(self, ns, cnns, flip_batch_x): 30 | 31 | rospy.loginfo("Starting Completion Server") 32 | 33 | self.flip_batch_x = flip_batch_x 34 | self.patch_size = 40 35 | self.cnns = cnns 36 | self.cnn_python_module = cnns[ns]["cnn_python_module"] 37 | self.weights_filepath = cnns[ns]["weights_filepath"] 38 | 39 | py_module = importlib.import_module(self.cnn_python_module) 40 | global model 41 | model = py_module.get_model() 42 | model.load_weights(self.weights_filepath) 43 | model._make_predict_function() 44 | 45 | self.post_process_executable = "mesh_reconstruction" 46 | 47 | self._feedback = pc_pipeline_msgs.msg.CompletePartialCloudFeedback() 48 | self._result = pc_pipeline_msgs.msg.CompletePartialCloudResult() 49 | 50 | self._as = actionlib.SimpleActionServer( 51 | ns + "/object_completion", 52 | pc_pipeline_msgs.msg.CompletePartialCloudAction, 53 | execute_cb=self.completion_cb, 54 | auto_start=False) 55 | 56 | self._switch_cnn_type_srv = rospy.Service( 57 | ns + '/shape_completion_server/set_cnn_type', 58 | pc_object_completion_cnn.srv.SetCNNType, self.set_cnn_type) 59 | 60 | self._as.start() 61 | 62 | rospy.loginfo("Started Completion Server") 63 | 64 | def complete_voxel_grid(self, batch_x_B012C): 65 | 66 | # The new version of keras takes the data as B012C 67 | # NOT BZCXY so we do not need to transpose it. 68 | batch_x = batch_x_B012C 69 | 70 | # run the batch through the network and get the completion 71 | # pred is actually flat, because we do not have a reshape as the final 72 | # layer of the net, so pred's shape is something like 73 | # (batch_size, 40*40*40) 74 | global model 75 | pred = model.predict(batch_x) 76 | 77 | # The new version of keras takes the data as B012C 78 | # NOT BZCXY so we do not need to transpose it. 79 | pred_as_b012c = pred.reshape(1, self.patch_size, self.patch_size, 80 | self.patch_size, 1) 81 | completed_region = pred_as_b012c[0, :, :, :, 0] 82 | 83 | return completed_region 84 | 85 | def set_cnn_type(self, request): 86 | cnn_name = request.cnn_name 87 | if cnn_name not in self.cnns: 88 | return shape_completion_server.srv.SetCNNTypeResponse( 89 | success=False) 90 | 91 | self.cnn_python_module = cnns[cnn_name]["cnn_python_module"] 92 | self.weights_filepath = cnns[cnn_name]["weights_filepath"] 93 | 94 | py_module = importlib.import_module(self.cnn_python_module) 95 | global model 96 | model = py_module.get_model() 97 | model.load_weights(self.weights_filepath) 98 | 99 | return shape_completion_server.srv.SetCNNTypeResponse(success=True) 100 | 101 | def completion_cb(self, goal): 102 | rospy.loginfo('Received Completion Goal') 103 | 104 | self._feedback = pc_pipeline_msgs.msg.CompletePartialCloudFeedback() 105 | self._result = pc_pipeline_msgs.msg.CompletePartialCloudResult() 106 | 107 | temp_pcd_handle, temp_pcd_filepath = tempfile.mkstemp(suffix=".pcd") 108 | os.close(temp_pcd_handle) 109 | partial_pc_np = curvox.cloud_transformations.cloud_msg_to_np( 110 | goal.partial_cloud) 111 | pcd = curvox.cloud_conversions.np_to_pcl(partial_pc_np) 112 | pcl.save(pcd, temp_pcd_filepath) 113 | 114 | partial_vox = curvox.pc_vox_utils.pc_to_binvox_for_shape_completion( 115 | points=partial_pc_np[:, 0:3], patch_size=self.patch_size) 116 | 117 | batch_x = np.zeros( 118 | (1, self.patch_size, self.patch_size, self.patch_size, 1), 119 | dtype=np.float32) 120 | batch_x[0, :, :, :, 0] = partial_vox.data 121 | 122 | 123 | if self.flip_batch_x: 124 | rospy.loginfo("Flipping Batch X, if performance is poor,\ 125 | try setting flip_batch_x=False") 126 | batch_x = batch_x.transpose(0, 2, 1, 3, 4) 127 | batch_x_new = np.zeros_like(batch_x) 128 | for i in range(40): 129 | batch_x_new[0, i, :, :, 0] = batch_x[0, 40 - i - 1, :, :, 0] 130 | 131 | batch_x = batch_x_new 132 | else: 133 | rospy.loginfo( 134 | "NOT Flipping Batch X, if performance is poor,\ 135 | try setting flip_batch_x=True" 136 | ) 137 | 138 | # output is the completed voxel grid, 139 | # it is all floats between 0,1 as last layer is softmax 140 | # think of this as probability of occupancy per voxel 141 | # output.shape = (X,Y,Z) 142 | output = self.complete_voxel_grid(batch_x) 143 | 144 | if self.flip_batch_x: 145 | rospy.loginfo("flipping batch x back") 146 | output_new = np.zeros_like(output) 147 | for i in range(40): 148 | output_new[i, :, :] = output[40 - i - 1, :, :] 149 | 150 | output = output_new 151 | output = output.transpose(1, 0, 2) 152 | 153 | # mask the output, so above 0.5 is occupied 154 | # below 0.5 is empty space. 155 | output_vox = np.array(output) > 0.5 156 | 157 | # Save the binary voxel grid as an occupancy map 158 | # in a binvox file 159 | completed_vox = binvox_rw.Voxels( 160 | output_vox, partial_vox.dims, partial_vox.translate, 161 | partial_vox.scale, partial_vox.axis_order) 162 | 163 | # Now we save the binvox file so that it can be passed to the 164 | # post processing along with the partial.pcd 165 | temp_handle, temp_binvox_filepath = tempfile.mkstemp( 166 | suffix="output.binvox") 167 | os.close(temp_handle) 168 | binvox_rw.write(completed_vox, open(temp_binvox_filepath, 'w')) 169 | 170 | # Now we save the binvox file so that it can be passed to the 171 | # post processing along with the partial.pcd 172 | temp_handle, temp_input_binvox_file = tempfile.mkstemp( 173 | suffix="input.binvox") 174 | os.close(temp_handle) 175 | binvox_rw.write(partial_vox, open(temp_input_binvox_file, 'w')) 176 | 177 | # This is the file that the post-processed mesh will be saved it. 178 | temp_handle, temp_completion_filepath = tempfile.mkstemp(suffix=".ply") 179 | os.close(temp_handle) 180 | # This command will look something like 181 | # mesh_reconstruction tmp/completion.binvox tmp/partial.pcd tmp/post_processed.ply 182 | cmd_str = self.post_process_executable + " " + temp_binvox_filepath + " " + temp_pcd_filepath \ 183 | + " " + temp_completion_filepath + " --cuda" 184 | 185 | subprocess.call(cmd_str.split(" ")) 186 | 187 | # Now we are going to read in the post-processed mesh, that is a merge 188 | # of the partial view and of the completion from the CNN 189 | temp_completion_ply = plyfile.PlyData.read(temp_completion_filepath) 190 | mesh = curvox.ros_mesh_conversions.ply_to_mesh_msg(temp_completion_ply) 191 | 192 | self._result.mesh = mesh 193 | 194 | self._as.set_succeeded(self._result) 195 | rospy.loginfo('Finished Msg') 196 | 197 | 198 | if __name__ == "__main__": 199 | 200 | parser = argparse.ArgumentParser( 201 | description="Complete a partial object view") 202 | parser.add_argument( 203 | "ns", 204 | type=str, 205 | help= 206 | "Namespace used to create action server, also determines what model to load. Ex: depth, depth_and_tactile" 207 | ) 208 | parser.add_argument( 209 | "--flip_batch_x", 210 | type=bool, 211 | default=True, 212 | help= 213 | "Z+ should be extending away from the camera, sometime binvox files have this as Y+ and need to be rotated. " 214 | ) 215 | args = parser.parse_args() 216 | cnns = { 217 | "depth": { 218 | "cnn_python_module": 219 | "shape_completion_server.trained_models.depth_y17_m05_d26_h14_m22_s35_bare_keras_v2.reconstruction_network", 220 | "weights_filepath": 221 | rospkg.RosPack().get_path('pc_object_completion_cnn') + 222 | '/scripts/shape_completion_server/trained_models/depth_y17_m05_d26_h14_m22_s35_bare_keras_v2/best_weights.h5' 223 | }, 224 | "depth_and_tactile": { 225 | "cnn_python_module": 226 | "shape_completion_server.trained_models.depth_and_tactile_y17_m08_d09_h15_m55_s53_bare_keras_v2.reconstruction_network", 227 | "weights_filepath": 228 | rospkg.RosPack().get_path('pc_object_completion_cnn') + 229 | '/scripts/shape_completion_server/trained_models/depth_and_tactile_y17_m08_d09_h15_m55_s53_bare_keras_v2/best_weights.h5' 230 | } 231 | } 232 | 233 | rospy.init_node(args.ns + "mesh_completion_node") 234 | server = MeshCompletionServer(args.ns, cnns, args.flip_batch_x) 235 | rospy.spin() 236 | --------------------------------------------------------------------------------