def set_action(self, action: Action) -> None:
# Get the force value
force = action.tolist()[0]
# Set the force value
model = self.world.get_model(self.model_name)
ok_force = model.get_joint("linear").set_generalized_force_target(force)
if not ok_force:
raise RuntimeError("Failed to set the force to the cart")
def set_action(self, action: Action) -> bool:
assert self.action_space.contains(action), \
"%r (%s) invalid" % (action, type(action))
# Get the robot object
robot = self.robot
# Read the action and send the force to the cart
force = action.tolist()[0]
ok = robot.set_joint_force("linear", force)
if not ok:
raise Exception("Failed to set the force to the cart")
return True
def set_action(self, action: Action) -> bool:
# Validate the action
assert self.action_space.contains(action), \
"%r (%s) invalid" % (action, type(action))
# Store the last action. It is used to calculate the reward.
self._last_a = action
# Read the action and send the force to the cart
force = action.tolist()[0]
ok = self.robot.set_joint_force("pivot", force)
if not ok:
raise Exception("Failed to set the force to the pendulum")
return True
def step(self, action: Action) -> State:
assert self.action_space.contains(action), \
"The action does not belong to the action space"
# The bindings do not accept yet numpy types as arguments. We need to covert
# numpy variables to the closer python type.
# Check if the input variable is a numpy type
is_numpy = type(action).__module__ == np.__name__
if is_numpy:
if isinstance(action, np.ndarray):
action = action.tolist()
elif isinstance(action, np.number):
action = action.item()
else:
assert False
# Actions must be std::vector objects, so if the passed action is a scalar
# we have to store it inside a list object before passing it to the bindings
if isinstance(action, Number):
action_list = [action]
else:
action_list = list(action)
# Create the gympp::Sample object
action_buffer = getattr(bindings, 'Vector' + self._act_dt)(action_list)
action_sample = bindings.Sample(action_buffer)
# Execute the step and get the std::optional<gympp::State> object
state_optional = self.gympp_env.step(action_sample)
assert state_optional.has_value()
# Get the gympp::State
state = state_optional.value()
# Get the std::vector buffer of gympp::Observation
observation_vector = getattr(state.observation, 'getBuffer' + self._obs_dt)()
assert observation_vector, "Failed to get the observation buffer"
assert observation_vector.size() > 0, "The observation does not contain elements"
# Convert the SWIG type to a list
observation_list = list(observation_vector)
# Convert the observation to a numpy array (this is the only required copy)
if isinstance(self.observation_space, gym.spaces.Box):
observation = np.array(observation_list)
elif isinstance(self.observation_space, gym.spaces.Discrete):
assert observation_vector.size() == 1, "The buffer has the wrong dimension"
observation = observation_list[0]
else:
assert False, "Space not supported"
assert self.observation_space.contains(observation), \
"The returned observation does not belong to the space"
# Create the info dict
info = {'gympp': state.info}
# Return the tuple
return State((observation, state.reward, state.done, info))