def _get_placement_initializer(self):
"""
Helper function for defining placement initializer and object sampling bounds.
"""
self.placement_initializer = SequentialCompositeSampler(
name="ObjectSampler")
# can sample anywhere in bin
bin_x_half = self.model.mujoco_arena.table_full_size[0] / 2 - 0.05
bin_y_half = self.model.mujoco_arena.table_full_size[1] / 2 - 0.05
# each object should just be sampled in the bounds of the bin (with some tolerance)
self.placement_initializer.append_sampler(sampler=UniformRandomSampler(
name="CollisionObjectSampler",
mujoco_objects=self.objects,
x_range=[-bin_x_half, bin_x_half],
y_range=[-bin_y_half, bin_y_half],
rotation=None,
rotation_axis="z",
ensure_object_boundary_in_range=True,
ensure_valid_placement=True,
reference_pos=self.bin1_pos,
z_offset=0.0,
))
# each visual object should just be at the center of each target bin
index = 0
for vis_obj in self.visual_objects:
# get center of target bin
bin_x_low = self.bin2_pos[0]
bin_y_low = self.bin2_pos[1]
if index == 0 or index == 2:
bin_x_low -= self.bin_size[0] / 2
if index < 2:
bin_y_low -= self.bin_size[1] / 2
bin_x_high = bin_x_low + self.bin_size[0] / 2
bin_y_high = bin_y_low + self.bin_size[1] / 2
bin_center = np.array([
(bin_x_low + bin_x_high) / 2.0,
(bin_y_low + bin_y_high) / 2.0,
])
# placement is relative to object bin, so compute difference and send to placement initializer
rel_center = bin_center - self.bin1_pos[:2]
self.placement_initializer.append_sampler(
sampler=UniformRandomSampler(
name=f"{vis_obj.name}ObjectSampler",
mujoco_objects=vis_obj,
x_range=[rel_center[0], rel_center[0]],
y_range=[rel_center[1], rel_center[1]],
rotation=0.0,
rotation_axis="z",
ensure_object_boundary_in_range=False,
ensure_valid_placement=False,
reference_pos=self.bin1_pos,
z_offset=self.bin2_pos[2] - self.bin1_pos[2],
))
index += 1
def _load_model(self):
"""
Loads an xml model, puts it in self.model
"""
super()._load_model()
# Adjust base pose accordingly
xpos = self.robots[0].robot_model.base_xpos_offset["table"](
self.table_full_size[0])
self.robots[0].robot_model.set_base_xpos(xpos)
# load model for table top workspace
mujoco_arena = TableArena(
table_full_size=self.table_full_size,
table_friction=self.table_friction,
table_offset=self.table_offset,
)
# Arena always gets set to zero origin
mujoco_arena.set_origin([0, 0, 0])
# initialize objects of interest
self.cube = BoxObject(
name="cube",
size_min=[0.020, 0.020, 0.020], # [0.015, 0.015, 0.015],
size_max=[0.022, 0.022, 0.022], # [0.018, 0.018, 0.018])
rgba=[1, 0, 0, 1],
)
self.goal = BoxObject(
name="goal",
size_min=[0.005, 0.005, 0.005],
size_max=[0.005, 0.005, 0.005],
rgba=[0, 0, 1, 1],
density=11342, # Density of lead such that the goal is hard to move
)
# Create placement initializer
if self.placement_initializer is not None:
self.placement_initializer.reset()
self.placement_initializer.add_objects([self.cube, self.goal])
else:
self.placement_initializer = UniformRandomSampler(
name="ObjectSampler",
mujoco_objects=[self.cube, self.goal],
x_range=[-0.20, 0.20],
y_range=[-0.20, 0.20],
rotation=None,
ensure_object_boundary_in_range=False,
ensure_valid_placement=True,
reference_pos=self.table_offset,
z_offset=0.01,
)
# task includes arena, robot, and objects of interest
self.model = ManipulationTask(
mujoco_arena=mujoco_arena,
mujoco_robots=[robot.robot_model for robot in self.robots],
mujoco_objects=[self.cube, self.goal],
)
def _load_model(self):
"""
Loads an xml model, puts it in self.model
"""
super()._load_model()
# Adjust base pose accordingly
xpos = self.robots[0].robot_model.base_xpos_offset["table"](self.table_full_size[0])
self.robots[0].robot_model.set_base_xpos(xpos)
# load model for table top workspace
mujoco_arena = TableArena(
table_full_size=self.table_full_size,
table_offset=self.table_offset,
)
# Arena always gets set to zero origin
mujoco_arena.set_origin([0, 0, 0])
# Modify default agentview camera
mujoco_arena.set_camera(
camera_name="agentview",
pos=[0.5986131746834771, -4.392035683362857e-09, 1.5903500240372423],
quat=[0.6380177736282349, 0.3048497438430786, 0.30484986305236816, 0.6380177736282349]
)
# initialize objects of interest
self.door = DoorObject(
name="Door",
friction=0.0,
damping=0.1,
lock=self.use_latch,
)
# Create placement initializer
if self.placement_initializer is not None:
self.placement_initializer.reset()
self.placement_initializer.add_objects(self.door)
else:
self.placement_initializer = UniformRandomSampler(
name="ObjectSampler",
mujoco_objects=self.door,
x_range=[0.07, 0.09],
y_range=[-0.01, 0.01],
rotation=(-np.pi / 2. - 0.25, -np.pi / 2.),
rotation_axis='z',
ensure_object_boundary_in_range=False,
ensure_valid_placement=True,
reference_pos=self.table_offset,
)
# task includes arena, robot, and objects of interest
self.model = ManipulationTask(
mujoco_arena=mujoco_arena,
mujoco_robots=[robot.robot_model for robot in self.robots],
mujoco_objects=self.door,
)
def _load_model(self):
"""
Loads an xml model, puts it in self.model
"""
super()._load_model()
# Adjust base pose accordingly
xpos = self.robots[0].robot_model.base_xpos_offset["table"](
self.table_full_size[0])
self.robots[0].robot_model.set_base_xpos(xpos)
# Load model for table top workspace
mujoco_arena = UltrasoundArena()
# Arena always gets set to zero origin
mujoco_arena.set_origin([0, 0, 0])
# Initialize torso object
self.torso = SoftBoxObject(
name="torso") if self.use_box_torso else SoftTorsoObject(
name="torso")
if self.torso_solref_randomization:
# Randomize torso's stiffness and damping (values are taken from my project thesis)
stiffness = np.random.randint(1300, 1600)
damping = np.random.randint(17, 41)
self.torso.set_damping(damping)
self.torso.set_stiffness(stiffness)
# Create placement initializer
if self.placement_initializer is not None:
self.placement_initializer.reset()
self.placement_initializer.add_objects(self.torso)
else:
self.placement_initializer = UniformRandomSampler(
name="ObjectSampler",
mujoco_objects=[self.torso],
x_range=[0, 0], #[-0.12, 0.12],
y_range=[0, 0], #[-0.12, 0.12],
rotation=None,
ensure_object_boundary_in_range=False,
ensure_valid_placement=True,
reference_pos=self.table_offset,
z_offset=0.005,
)
# task includes arena, robot, and objects of interest
self.model = UltrasoundTask(
mujoco_arena=mujoco_arena,
mujoco_robots=[robot.robot_model for robot in self.robots],
mujoco_objects=[self.torso])
def _load_model(self):
"""
Loads an xml model, puts it in self.model
"""
super()._load_model()
# Adjust base pose accordingly
xpos = self.robots[0].robot_model.base_xpos_offset["table"](
self.table_full_size[0])
self.robots[0].robot_model.set_base_xpos(xpos)
# load model for table top workspace
mujoco_arena = UltrasoundArena()
# Arena always gets set to zero origin
mujoco_arena.set_origin([0, 0, 0])
# initialize objects of interest
self.torso = SoftTorsoObject(name="torso")
# Create placement initializer
if self.placement_initializer is not None:
self.placement_initializer.reset()
self.placement_initializer.add_objects(self.torso)
else:
self.placement_initializer = UniformRandomSampler(
name="ObjectSampler",
mujoco_objects=[self.torso],
x_range=[0, 0], #[-0.12, 0.12],
y_range=[0, 0], #[-0.12, 0.12],
rotation=None,
ensure_object_boundary_in_range=False,
ensure_valid_placement=True,
reference_pos=self.table_offset,
z_offset=0.005,
)
# task includes arena, robot, and objects of interest
self.model = UltrasoundTask(
mujoco_arena=mujoco_arena,
mujoco_robots=[robot.robot_model for robot in self.robots],
mujoco_objects=[self.torso])
def _reset_internal(self):
"""
Resets simulation internal configurations.
"""
super()._reset_internal()
# Reset all object positions using initializer sampler if we're not directly loading from an xml
if not self.deterministic_reset:
eef_pos = self.robots[0].sim.data.get_body_xpos('gripper0_eef')
self.ball_initializer = UniformRandomSampler(
name="ObjectSampler",
mujoco_objects=self.ball,
x_range=[-self.max_object_distance, self.max_object_distance],
y_range=[-self.max_object_distance, self.max_object_distance],
rotation=None,
reference_pos=eef_pos,
ensure_object_boundary_in_range=False,
ensure_valid_placement=True,
)
ball_id = self.sim.model.body_name2id(self.ball.root_body)
distance = 1.0
print(distance)
while distance > .8:
# TODO what about z?
z = np.random.uniform(high=eef_pos[2]+self.max_object_distance, low=eef_pos[2]-self.max_object_distance)
# Sample from the placement initializer for all objects
object_placements = self.ball_initializer.sample()
new_position = np.array(object_placements['ball'][0])
new_position[2] = z
distance = np.sqrt(np.sum(new_position)**2)
print('setting ball', new_position)
self.sim.data.body_xpos[ball_id] = new_position
# below only works if there are joints - but we don't want joint bc we need static ball
# Loop through all objects and reset their positions
self.sim.data.set_joint_qpos('ball_x', new_position[0])
self.sim.data.set_joint_qpos('ball_y', new_position[1])
self.sim.data.set_joint_qpos('ball_z', new_position[2])
def __init__(self,
robots,
table_full_size=TABLE_TOP_SIZE,
table_offset=TABLE_OFFSET,
placement_initializer=None,
penalize_reward_on_collision=False,
end_episode_on_collision=False,
**kwargs):
"""
Args:
robots (str or list of str): Specification for specific robot arm(s) to be instantiated within this env
(e.g: "Sawyer" would generate one arm; ["Panda", "Panda", "Sawyer"] would generate three robot arms)
Note: Must be a single single-arm robot!
table_full_size (3-tuple): x, y, and z dimensions of the table.
placement_initializer (ObjectPositionSampler instance): if provided, will
be used to place objects on every reset, else a UniformRandomSampler
is used by default.
Rest of kwargs follow Lift class arguments
"""
if placement_initializer is None:
placement_initializer = UniformRandomSampler(
name="ObjectSampler",
x_range=[0.0, 0.0],
y_range=[0.0, 0.0],
rotation=(0.0, 0.0),
ensure_object_boundary_in_range=False,
ensure_valid_placement=True,
reference_pos=table_offset,
z_offset=0.9,
)
super().__init__(robots=robots,
table_full_size=table_full_size,
placement_initializer=placement_initializer,
initialization_noise=None,
**kwargs)
self._max_episode_steps = self.horizon
def _load_model(self):
"""
Loads an xml model, puts it in self.model
"""
super()._load_model()
# Adjust base pose(s) accordingly
if self.env_configuration == "bimanual":
xpos = self.robots[0].robot_model.base_xpos_offset["table"](self.table_full_size[0])
self.robots[0].robot_model.set_base_xpos(xpos)
else:
if self.env_configuration == "single-arm-opposed":
# Set up robots facing towards each other by rotating them from their default position
for robot, rotation in zip(self.robots, (np.pi/2, -np.pi/2)):
xpos = robot.robot_model.base_xpos_offset["table"](self.table_full_size[0])
rot = np.array((0, 0, rotation))
xpos = T.euler2mat(rot) @ np.array(xpos)
robot.robot_model.set_base_xpos(xpos)
robot.robot_model.set_base_ori(rot)
else: # "single-arm-parallel" configuration setting
# Set up robots parallel to each other but offset from the center
for robot, offset in zip(self.robots, (-0.25, 0.25)):
xpos = robot.robot_model.base_xpos_offset["table"](self.table_full_size[0])
xpos = np.array(xpos) + np.array((0, offset, 0))
robot.robot_model.set_base_xpos(xpos)
# load model for table top workspace
mujoco_arena = TableArena(
table_full_size=self.table_full_size,
table_friction=self.table_friction,
table_offset=self.table_offset,
)
# Arena always gets set to zero origin
mujoco_arena.set_origin([0, 0, 0])
# initialize objects of interest
self.pot = PotWithHandlesObject(name="pot")
# Create placement initializer
if self.placement_initializer is not None:
self.placement_initializer.reset()
self.placement_initializer.add_objects(self.pot)
else:
self.placement_initializer = UniformRandomSampler(
name="ObjectSampler",
mujoco_objects=self.pot,
x_range=[-0.03, 0.03],
y_range=[-0.03, 0.03],
ensure_object_boundary_in_range=False,
ensure_valid_placement=True,
reference_pos=self.table_offset,
rotation=(np.pi + -np.pi / 3, np.pi + np.pi / 3),
)
# task includes arena, robot, and objects of interest
self.model = ManipulationTask(
mujoco_arena=mujoco_arena,
mujoco_robots=[robot.robot_model for robot in self.robots],
mujoco_objects=self.pot,
)
def _load_model(self):
"""
Loads an xml model, puts it in self.model
"""
super()._load_model()
# Adjust base pose(s) accordingly
if self.env_configuration == "bimanual":
xpos = self.robots[0].robot_model.base_xpos_offset["table"](
self.table_full_size[0])
self.robots[0].robot_model.set_base_xpos(xpos)
else:
if self.env_configuration == "single-arm-opposed":
# Set up robots facing towards each other by rotating them from their default position
for robot, rotation, offset in zip(self.robots,
(np.pi / 2, -np.pi / 2),
(-0.25, 0.25)):
xpos = robot.robot_model.base_xpos_offset["table"](
self.table_full_size[0])
rot = np.array((0, 0, rotation))
xpos = T.euler2mat(rot) @ np.array(xpos)
xpos += np.array((0, offset, 0))
robot.robot_model.set_base_xpos(xpos)
robot.robot_model.set_base_ori(rot)
else: # "single-arm-parallel" configuration setting
# Set up robots parallel to each other but offset from the center
for robot, offset in zip(self.robots, (-0.6, 0.6)):
xpos = robot.robot_model.base_xpos_offset["table"](
self.table_full_size[0])
xpos = np.array(xpos) + np.array((0, offset, 0))
robot.robot_model.set_base_xpos(xpos)
# load model for table top workspace
mujoco_arena = TableArena(table_full_size=self.table_true_size,
table_friction=self.table_friction,
table_offset=self.table_offset)
# Arena always gets set to zero origin
mujoco_arena.set_origin([0, 0, 0])
# Modify default agentview camera
mujoco_arena.set_camera(camera_name="agentview",
pos=[
0.8894354364730311, -3.481824231498976e-08,
1.7383813133506494
],
quat=[
0.6530981063842773, 0.2710406184196472,
0.27104079723358154, 0.6530979871749878
])
# initialize objects of interest
self.hammer = HammerObject(name="hammer")
# Create placement initializer
if self.placement_initializer is not None:
self.placement_initializer.reset()
self.placement_initializer.add_objects(self.hammer)
else:
# Set rotation about y-axis if hammer starts on table else rotate about z if it starts in gripper
rotation_axis = 'y' if self.prehensile else 'z'
self.placement_initializer = UniformRandomSampler(
name="ObjectSampler",
mujoco_objects=self.hammer,
x_range=[-0.1, 0.1],
y_range=[-0.05, 0.05],
rotation=None,
rotation_axis=rotation_axis,
ensure_object_boundary_in_range=False,
ensure_valid_placement=True,
reference_pos=self.table_offset,
)
# task includes arena, robot, and objects of interest
self.model = ManipulationTask(
mujoco_arena=mujoco_arena,
mujoco_robots=[robot.robot_model for robot in self.robots],
mujoco_objects=self.hammer,
)
def _load_model(self):
"""
Loads an xml model, puts it in self.model
"""
super()._load_model()
# Adjust base pose accordingly
xpos = self.robots[0].robot_model.base_xpos_offset["table"](
self.table_full_size[0])
self.robots[0].robot_model.set_base_xpos(xpos)
# load model for table top workspace
mujoco_arena = TableArena(
table_full_size=self.table_full_size,
table_friction=self.table_friction,
table_offset=self.table_offset,
)
# Arena always gets set to zero origin
mujoco_arena.set_origin([0, 0, 0])
# initialize objects of interest
tex_attrib = {
"type": "cube",
}
mat_attrib = {
"texrepeat": "1 1",
"specular": "0.4",
"shininess": "0.1",
}
redwood = CustomMaterial(
texture="WoodRed",
tex_name="redwood",
mat_name="redwood_mat",
tex_attrib=tex_attrib,
mat_attrib=mat_attrib,
)
greenwood = CustomMaterial(
texture="WoodGreen",
tex_name="greenwood",
mat_name="greenwood_mat",
tex_attrib=tex_attrib,
mat_attrib=mat_attrib,
)
self.cubeA = BoxObject(
name="cubeA",
size_min=[0.02, 0.02, 0.02],
size_max=[0.02, 0.02, 0.02],
rgba=[1, 0, 0, 1],
material=redwood,
)
self.cubeB = BoxObject(
name="cubeB",
size_min=[0.025, 0.025, 0.025],
size_max=[0.025, 0.025, 0.025],
rgba=[0, 1, 0, 1],
material=greenwood,
)
cubes = [self.cubeA, self.cubeB]
# Create placement initializer
if self.placement_initializer is not None:
self.placement_initializer.reset()
self.placement_initializer.add_objects(cubes)
else:
self.placement_initializer = UniformRandomSampler(
name="ObjectSampler",
mujoco_objects=cubes,
x_range=[-0.08, 0.08],
y_range=[-0.08, 0.08],
rotation=None,
ensure_object_boundary_in_range=False,
ensure_valid_placement=True,
reference_pos=self.table_offset,
z_offset=0.01,
)
# task includes arena, robot, and objects of interest
self.model = ManipulationTask(
mujoco_arena=mujoco_arena,
mujoco_robots=[robot.robot_model for robot in self.robots],
mujoco_objects=cubes,
)
def _load_model(self):
"""
Loads an xml model, puts it in self.model
"""
super()._load_model()
# Adjust base pose accordingly
xpos = self.robots[0].robot_model.base_xpos_offset["table"](
self.table_full_size[0])
self.robots[0].robot_model.set_base_xpos(xpos)
# load model for table top workspace
mujoco_arena = PegsArena(
table_full_size=self.table_full_size,
table_friction=self.table_friction,
table_offset=self.table_offset,
)
# Arena always gets set to zero origin
mujoco_arena.set_origin([0, 0, 0])
# define nuts
self.nuts = []
nut_names = ("SquareNut", "RoundNut")
# Create default (SequentialCompositeSampler) sampler if it has not already been specified
if self.placement_initializer is None:
self.placement_initializer = SequentialCompositeSampler(
name="ObjectSampler")
for nut_name, default_y_range in zip(
nut_names, ([0.11, 0.225], [-0.225, -0.11])):
self.placement_initializer.append_sampler(
sampler=UniformRandomSampler(
name=f"{nut_name}Sampler",
x_range=[-0.115, -0.11],
y_range=default_y_range,
rotation=None,
rotation_axis="z",
ensure_object_boundary_in_range=False,
ensure_valid_placement=True,
reference_pos=self.table_offset,
z_offset=0.02,
))
# Reset sampler before adding any new samplers / objects
self.placement_initializer.reset()
for i, (nut_cls, nut_name) in enumerate(
zip(
(SquareNutObject, RoundNutObject),
nut_names,
)):
nut = nut_cls(name=nut_name)
self.nuts.append(nut)
# Add this nut to the placement initializer
if isinstance(self.placement_initializer,
SequentialCompositeSampler):
# assumes we have two samplers so we add nuts to them
self.placement_initializer.add_objects_to_sampler(
sampler_name=f"{nut_name}Sampler", mujoco_objects=nut)
else:
# This is assumed to be a flat sampler, so we just add all nuts to this sampler
self.placement_initializer.add_objects(nut)
# task includes arena, robot, and objects of interest
self.model = ManipulationTask(
mujoco_arena=mujoco_arena,
mujoco_robots=[robot.robot_model for robot in self.robots],
mujoco_objects=self.nuts,
)
def _load_model(self):
"""
Loads an xml model, puts it in self.model
"""
super()._load_model()
# Adjust base pose accordingly
xpos = self.robots[0].robot_model.base_xpos_offset["table"](
self.table_full_size[0])
self.robots[0].robot_model.set_base_xpos(xpos)
# load model for table top workspace
mujoco_arena = TableArena(
table_full_size=self.table_full_size,
table_friction=self.table_friction,
table_offset=self.table_offset,
)
# Arena always gets set to zero origin
mujoco_arena.set_origin([0, 0, 0])
# Load hole object
# register object with the corresponding option (objectClass, name, xrange, yrange)
if self.task_configs['board'] == 'GMC_assembly':
self.register_object(my_object.GMC_Assembly_Object,
'plate',
xrange=[0, 0],
yrange=[0, 0])
if self.task_configs['board'] == 'GMC_plate':
self.register_object(my_object.GMC_Plate_Object,
'plate',
xrange=[0, 0],
yrange=[0, 0])
if self.task_configs['board'] == 'Square_hole_16mm':
self.register_object(my_object.square_hole_16mm,
'plate',
xrange=[0, 0],
yrange=[0, 0])
# Load peg object
if self.task_configs['peg'] == '16mm':
self.register_object(my_object.Round_peg_16mm_Object,
'peg',
xrange=[-0.1, -0.13],
yrange=[0.3, 0.33])
elif self.task_configs['peg'] == '12mm':
self.register_object(my_object.Round_peg_12mm_Object,
'peg',
xrange=[-0.1, -0.13],
yrange=[0.3, 0.33])
elif self.task_configs['peg'] == '9mm':
raise NotImplementedError
elif self.task_configs['peg'] == 'cylinder_16mm':
from robosuite.models.objects.primitive import CylinderObject
self.peg = CylinderObject('peg', size=(0.007, 0.025))
self.objects_of_interest.append(self.peg)
self.objectsName_of_interest.append('peg')
self.objectsXrange_of_interest.append([-0.1, -0.13])
self.objectsYrange_of_interest.append([0.3, 0.33])
# Create Sequential Sampler. The order is same as the order of register.
# Create individual samplers per object
self.placement_initializer = SequentialCompositeSampler(
name="ObjectSampler")
for obj_name, default_xy_range in zip(
self.objectsName_of_interest,
zip(self.objectsXrange_of_interest,
self.objectsYrange_of_interest)):
self.placement_initializer.append_sampler(
sampler=UniformRandomSampler(
name=f"{obj_name}Sampler",
x_range=default_xy_range[0],
y_range=default_xy_range[1],
rotation=None,
rotation_axis='z',
ensure_object_boundary_in_range=True,
ensure_valid_placement=True,
reference_pos=self.table_offset,
z_offset=0.01,
))
# Add objects to the sampler
for obj_to_put, obj_name in zip(self.objects_of_interest,
self.objectsName_of_interest):
self.placement_initializer.add_objects_to_sampler(
sampler_name=f"{obj_name}Sampler", mujoco_objects=obj_to_put)
if self.task_configs['board'] == 'hole':
self.plate = PlateWithHoleObject(name='plate')
plate_obj = self.plate.get_obj()
plate_obj.set("quat", "0 0 0 1")
plate_obj.set("pos", "0 0 {}".format(self.table_offset[2]))
self.objects_of_interest.append(self.plate)
# task includes arena, robot, and objects of interest
self.model = ManipulationTask(
mujoco_arena=mujoco_arena,
mujoco_robots=[robot.robot_model for robot in self.robots],
mujoco_objects=self.objects_of_interest,
)
def _load_model(self):
"""
Loads an xml model, puts it in self.model
"""
super()._load_model()
# Adjust base pose accordingly
xpos = self.robots[0].robot_model.base_xpos_offset["table"](
self.table_full_size[0])
self.robots[0].robot_model.set_base_xpos(xpos)
# load model for table top workspace
#mujoco_arena = TableArena(
# table_full_size=self.table_full_size,
# table_friction=self.table_friction,
# table_offset=self.table_offset,
#)
mujoco_arena = EmptyArena()
# Arena always gets set to zero origin
mujoco_arena.set_origin([0, 0, 0])
# initialize objects of interest
tex_attrib = {
"type": "ball",
}
mat_attrib = {
"texrepeat": "1 1",
"specular": "0.4",
"shininess": "0.1",
}
redwood = CustomMaterial(
texture="WoodRed",
tex_name="redwood",
mat_name="redwood_mat",
tex_attrib=tex_attrib,
mat_attrib=mat_attrib,
)
self.ball = BallObject(
name="ball",
size_min=[0.018], # [0.015, 0.015, 0.015],
size_max=[0.024], # [0.018, 0.018, 0.018])
rgba=[1, 0, 0, 1],
density=1,
joints=[
{"name":"ball_x",
"type":"slide",
"damping":100,
"axis":"1 0 0",
},
{"name":"ball_y",
"type":"slide",
"damping":100,
"axis":"0 1 0"},
{"name":"ball_z",
"type":"slide",
"axis":"0 0 1",
"damping":100,
}
]
)
# get current end effector position
#max_pos = [-.75, .75] #np.clip(self.max_object_distance + eef_pos[:3], -1, 1)
#min_pos = [-.75, .75] #np.clip(-self.max_object_distance + eef_pos[:3], -1, 1)
## Create placement initializer
# TODO I think we need to create every time since joint position will be different
if self.placement_initializer is not None:
self.placement_initializer.reset()
self.placement_initializer.add_objects(self.ball)
else:
self.placement_initializer = UniformRandomSampler(
name="ObjectSampler",
mujoco_objects=self.ball,
x_range=[-.75, .75],
y_range=[-.75, .75],
rotation=None,
ensure_object_boundary_in_range=False,
ensure_valid_placement=True,
reference_pos=self.table_offset,
)
# task includes arena, robot, and objects of interest
self.model = ManipulationTask(
mujoco_arena=mujoco_arena,
mujoco_robots=[robot.robot_model for robot in self.robots],
mujoco_objects=self.ball,
)