def del_one_model(self):
if len(self.added_models) > 0:
delReq = DeleteModelRequest()
delReq.model_name = self.added_models.pop()
tmp = self.modelsPoses.pop()
tmpResp = self.delete_model_proxy(delReq)
rospy.loginfo("delete model to gazebo success: " +
str(tmpResp.success))
if tmpResp.success:
info = "Deleted model: " + str(delReq.model_name) + " succeed!"
rospy.loginfo(info)
else:
status_message = "Delete failed due to unknown reason"
rospy.logwarn(status_message)
tmpResp.status_message = status_message
else:
status_message = "No model to be deleted"
rospy.logwarn(status_message)
tmpResp = DeleteModelResponse()
tmpResp.status_message = status_message
resp = TriggerResponse()
resp.success = tmpResp.success
resp.message = tmpResp.status_message
return resp
def delete():
try:
srv = ServiceProxy('/gazebo/delete_model', DeleteModel)
req = DeleteModelRequest()
req.model_name = "turtlebot3_burger"
resp = srv(req)
except ServiceException, e:
print("Service call failed: %s" % e)
return
def _despawn_ball(self):
"""
Despawns the ball, if it is there.
:returns None.
"""
if self._ball_spawned:
msg = DeleteModelRequest()
msg.model_name = self._ball_name
self._despawn_proxy(msg)
self._ball_spawned = False
def del_model(self, name):
""" delete a model whose name contains given name
Args:
name (string): part of model name
"""
get_world_properties_request = GetWorldPropertiesRequest()
delete_request = DeleteModelRequest()
resp = self.get_world_properties_srv(get_world_properties_request)
for model in resp.model_names:
if name in model:
delete_request.model_name = model
self.delete_srv(delete_request)
break
def timer_callback(self, event):
"""In this callback, we find out all the stale data and remove the corresponding models."""
if bool(self.all_data): # if dict not empty
for name, data_w_time in self.all_data.iteritems():
if rospy.Time.now() - data_w_time[1] > rospy.Duration(10): # If data is staler than 30 secs
rospy.logwarn("Removing {} from data since its stale".format(name))
self.all_data.pop(name)
request = DeleteModelRequest()
request.model_name = name
response = self.delete_model(request)
rospy.loginfo(response)
break # Since we are popping an element, it will mess up the for loop. Remove one at a time.
def delete_model(mav_sys_id, vehicle_type, ros_master_uri=None):
if ros_master_uri:
original_uri = os.environ[ROS_MASTER_URI]
os.environ[ROS_MASTER_URI] = ros_master_uri
try:
srv = ServiceProxy('/gazebo/delete_model', DeleteModel)
req = DeleteModelRequest()
unique_name = 'uav' + str(mav_sys_id)
req.model_name = unique_name
resp = srv(req)
except ServiceException, e:
print_error("===================================================================================")
print_error(" Service call failed: %s" % e)
print_error("===================================================================================")
sys.exit(2)
def remove_robot(self):
'''
Remove an object
https://github.com/ipa320/srs_public/blob/master/srs_user_tests/ros/scripts/spawn_object.py
'''
# print("Remove object")
name = "iiwa"
rospy.wait_for_service("/gazebo/delete_model")
srv_delete_model = rospy.ServiceProxy('/gazebo/delete_model', DeleteModel)
req = DeleteModelRequest()
req.model_name = name
# res = srv_delete_model(name)
try:
res = srv_delete_model(name)
except rospy.ServiceException, e:
print("ERROR: CANNOT REMOVE Robot: ", name)
def spawn_robot():
rospy.wait_for_service("/gazebo/spawn_urdf_model")
file_localition = roslib.packages.get_pkg_dir(
'aliengo_description') + '/xacro/robot.xacro'
p = os.popen("rosrun xacro xacro " + file_localition)
xml_string = p.read()
p.close()
srv_spawn_model = rospy.ServiceProxy('/gazebo/spawn_urdf_model',
SpawnModel)
srv_delete_model = rospy.ServiceProxy('/gazebo/delete_model', DeleteModel)
req = DeleteModelRequest()
name = "laikago_gazebo"
req.model_name = name
try:
res = srv_delete_model(name)
except rospy.ServiceException, e:
rospy.logdebug("Model %s does not exist in gazebo.", name)
def spawn_box():
# pauseSim()
rospy.wait_for_service("/gazebo/spawn_urdf_model")
file_localition = roslib.packages.get_pkg_dir(
'aliengo_gazebo') + '/launch/world/my_box.urdf'
p = os.popen("rosrun xacro xacro " + file_localition)
xml_string = p.read()
p.close()
srv_spawn_model = rospy.ServiceProxy('/gazebo/spawn_urdf_model',
SpawnModel)
srv_delete_model = rospy.ServiceProxy('/gazebo/delete_model', DeleteModel)
req = DeleteModelRequest()
name = "box"
req.model_name = name
try:
res = srv_delete_model(name)
except rospy.ServiceException, e:
rospy.logdebug("Model %s does not exist in gazebo.", name)
def delete_model(self, model_name):
# check if object is already spawned
srv_delete_model = rospy.ServiceProxy('gazebo/delete_model',
DeleteModel)
req = DeleteModelRequest()
req.model_name = model_name
try:
res = srv_delete_model(req)
result_ok = res.success
result_msg = res.status_message
rospy.loginfo(result_msg)
except rospy.ServiceException as e:
result_ok = False
result_msg = "Model " + model_name + " does not exist in gazebo, e=" + str(
e)
rospy.logerr(result_msg)
return result_ok, result_msg
def delAllModelSrvCb(req):
worldProp = gazeboModelCli.get_worldProperties_proxy(
GetWorldPropertiesRequest())
if len(worldProp.model_names) > 2:
modelsToDel = worldProp.model_names[2:]
for modelName in modelsToDel:
delModelReq = DeleteModelRequest()
delModelReq.model_name = modelName
gazeboModelCli.delete_model_proxy(delModelReq)
gazeboModelCli.added_models = []
gazeboModelCli.modelsPoses = []
gazeboModelCli.noisyPoses = []
msg = "All model deleted!"
else:
msg = "No model to be deleted!"
fakeRecPub.setMsg(gazeboModelCli.added_models, gazeboModelCli.modelsPoses)
fakeRecPub.pubOnce(add_noise=True)
resp = TriggerResponse()
resp.success = True
rospy.loginfo(msg)
resp.message = msg
gazeboModelCli.reset()
return resp
def delete_model(mav_sys_id, vehicle_type, ros_master_uri=None):
if ros_master_uri:
original_uri = os.environ[ROS_MASTER_URI]
os.environ[ROS_MASTER_URI] = ros_master_uri
srv = ServiceProxy('/gazebo/delete_model', DeleteModel)
req = DeleteModelRequest()
unique_name = vehicle_type + '_' + str(mav_sys_id)
req.model_name = unique_name
resp = srv(req)
if ros_master_uri:
os.environ[ROS_MASTER_URI] = original_uri
if resp.success:
print(resp.status_message, '(%s)' % unique_name)
return 0
else:
print("failed to delete model [%s]: %s" %
(unique_name, resp.status_message),
file=sys.stderr)
return 1
def reset(self):
"""
Resets the state of the thimblerigger.
Specifically, it:
- Hides the ball
- Chooses a new mug for the ball to be under
:returns True.
"""
clientLogger.info("(Re)setting thimblerigger experiment.")
self._despawn_ball()
self._hide_ball()
self.send_training_signal = False
for mug_name in self.mug_order:
msg = DeleteModelRequest()
msg.model_name = mug_name
self._despawn_proxy(msg)
self._spawn_mugs()
self.choose_mug_for_ball()
return True
#! /usr/bin/env python
from gazebo_msgs.srv import DeleteModel, DeleteModelRequest # Import the service message
import sys
import rospy
rospy.init_node(
'service_client') # Initialise a ROS node with the name service_client
rospy.wait_for_service(
'/gazebo/delete_model') # Wait for the service client /gazebo/delete_model
delete_model_service = rospy.ServiceProxy(
'/gazebo/delete_model', DeleteModel) # Create the service client
kk = DeleteModelRequest() # Create an object of type DeleteModelRequest
kk.model_name = "rubble_1" # Fill the variable model_name of this object with the desired value
result = delete_model_service(
kk
) # Send through the connection the name of the object to the service node
print result # Print the result given by the service called
#! /usr/bin/env python
import rospy
from gazebo_msgs.srv import DeleteModel, DeleteModelRequest # Import the service message used by the service /gazebo/delete_model
import sys
rospy.init_node(
'service_client') # Initialise a ROS node with the name service_client
rospy.wait_for_service(
'/gazebo/delete_model'
) # Wait for the service client /gazebo/delete_model to be running
delete_model_service = rospy.ServiceProxy(
'/gazebo/delete_model',
DeleteModel) # Create the connection to the service
kk = DeleteModelRequest() # Create an object of type DeleteModelRequest
kk.model_name = "bowl_2" # Fill the variable model_name of this object with the desired value
result = delete_model_service(
kk
) # Send through the connection the name of the object to be deleted by the service
print result # Print the result given by the service called
objects = {}
for object_name in object_names:
if object_name in list(flat_objects.keys()):
objects.update({object_name: flat_objects[object_name]})
elif sys.argv[1] not in list(flat_objects.keys()):
rospy.logerr("Object %s not found", sys.argv[1])
sys.exit()
else:
objects = {sys.argv[1]: flat_objects[sys.argv[1]]}
rospy.loginfo("Trying to remove %s", list(objects.keys()))
for name in objects:
# check if object is already spawned
srv_delete_model = rospy.ServiceProxy('gazebo/delete_model',
DeleteModel)
req = DeleteModelRequest()
req.model_name = name
exists = True
try:
rospy.wait_for_service('/gazebo/delete_model')
res = srv_delete_model(name)
except rospy.ServiceException:
exists = False
rospy.logdebug("Model %s does not exist in gazebo.", name)
if exists:
rospy.loginfo("Model %s removed.", name)
else:
rospy.logerr("Model %s not found in gazebo.", name)
def call_delete_ramp(self):
rospy.loginfo("Deleting ramp")
del_req = DeleteModelRequest()
del_req.model_name = "ramp"
resp = self.delete_srv.call(del_req)
rospy.loginfo("Resp of delete: " + str(resp))
def call_delete(self):
rospy.loginfo("Deleting " + str(self.curr_cfg["MODELNAME_"]))
del_req = DeleteModelRequest()
del_req.model_name = str(self.curr_cfg["MODELNAME_"])
resp = self.delete_srv.call(del_req)
rospy.loginfo("Resp of delete: " + str(resp))
#! /usr/bin/env python
import rospy
from gazebo_msgs.srv import DeleteModel, DeleteModelRequest # Import the service message used by the service /gazebo/delete_model
import sys
rospy.init_node('remove_model_service_client'
) # Initialise a ROS node with the name service_client
print "Waiting for Service /gazebo/delete_model"
rospy.wait_for_service(
'/gazebo/delete_model'
) # Wait for the service client /gazebo/delete_model to be running
delete_model_service = rospy.ServiceProxy(
'/gazebo/delete_model',
DeleteModel) # Create the connection to the service
kk = DeleteModelRequest() # Create an object of type DeleteModelRequest
kk.model_name = "qtrobot" # Fill the variable model_name of this object with the desired value
print "Deleting model =" + str(kk)
status_message = delete_model_service(
kk
) # Send through the connection the name of the object to be deleted by the service
print status_message
#! /usr/bin/env python
import rospy
from gazebo_msgs.srv import DeleteModel, DeleteModelRequest
import sys
rospy.init_node('remove_model_service_client')
print "waiting for service..."
rospy.wait_for_service('/gazebo/delete_model')
delete_model_service = rospy.ServiceProxy('/gazebo/delete_model', DeleteModel)
kk = DeleteModelRequest()
kk.model_name = 'mira'
print "Deleting model = " + str(kk)
status_msg = delete_model_service(kk)
print status_msg
#! /usr/bin/env python
import rospy
# Import the service message used by the service /gazebo/delete_model
from gazebo_msgs.srv import DeleteModel, DeleteModelRequest
import sys
# Initialise a ROS node with the name service_client
rospy.init_node('service_client')
# Wait for the service client /gazebo/delete_model to be running
rospy.wait_for_service('/gazebo/delete_model')
# Create the connection to the service
delete_model_service = rospy.ServiceProxy('/gazebo/delete_model', DeleteModel)
# Create an object of type DeleteModelRequest
delete_model_object = DeleteModelRequest()
# Fill the variable model_name of this object with the desired value
delete_model_object.model_name = "bowl_1"
# Send through the connection the name of the object to be deleted by the service
result = delete_model_service(delete_model_object)
# Print the result given by the service called
print result
#!/usr/bin/python3
import rospy
from moveit_commander.move_group import MoveGroupCommander
from geometry_msgs.msg import Pose
from math import radians, cos, sin
from gazebo_msgs.srv import SpawnModel, DeleteModel, DeleteModelRequest
colors = ['Blue', 'Red', 'Green', 'Purple']
srv = rospy.ServiceProxy('/gazebo/delete_model', DeleteModel)
req = DeleteModelRequest()
for x in colors:
for y in range(3):
req.model_name = "mp" + x + str(y)
resp = srv(req)
if resp.success:
print(resp.status_message, '(%s)' % x)
else:
print("failed to delete model [%s]" % x)
#! /usr/bin/env python
from gazebo_msgs.srv import DeleteModel, DeleteModelRequest
# Import the service message
import sys
import rospy
rospy.init_node('service_client')
# Initialise a ROS node with the name service_client
#Overview: call service --> create client variable --> create object variable -->...
#... assign object name --> call client variable with object variable as argument
rospy.wait_for_service('/gazebo/delete_model')
# Wait for the service client /gazebo/delete_model
delete_model_service = rospy.ServiceProxy('/gazebo/delete_model', DeleteModel)
# Create the service client
kk = DeleteModelRequest()
# Create an object of type DeleteModelRequest
kk.model_name = "right_wall"
# Fill the variable model_name of this object with the desired value
result = delete_model_service(kk)
# Send through the connection the name of the object to the service node
print result
