def test_list_sensors():
playground = SingleRoom(size=(300, 200))
agent_1 = BaseAgent(
controller=External(),
interactive=False,
rotate=False,
lateral=False
)
sensor_1 = RgbCamera(anchor=agent_1.base_platform, invisible_elements=agent_1.parts, range=400)
sensor_2 = Lidar(anchor=agent_1.base_platform, invisible_elements=agent_1.parts, range=400)
sensor_3 = SemanticRay(anchor=agent_1.base_platform, invisible_elements=agent_1.parts, range=400)
agent_1.add_sensor(sensor_1)
agent_1.add_sensor(sensor_2)
agent_1.add_sensor(sensor_3)
playground.add_agent(agent_1, ((100, 100), 0))
disabler = SensorDisabler(disabled_sensor_types=[RgbCamera, SemanticRay])
playground.add_element(disabler, ((100, 100), 0))
engine = Engine(playground)
engine.step()
engine.update_observations()
for sensor in [sensor_1, sensor_2, sensor_3]:
if isinstance(sensor, RgbCamera):
assert sensor._disabled
assert np.all(sensor.sensor_values == sensor._get_null_sensor())
elif isinstance(sensor, SemanticRay):
assert sensor._disabled
assert sensor.sensor_values == sensor._get_null_sensor()
else:
assert not sensor._disabled
if isinstance(sensor.sensor_values, np.ndarray):
assert not np.all(sensor.sensor_values == sensor._get_null_sensor())
else:
assert not sensor.sensor_values == sensor._get_null_sensor()
def test_normalize_position_sensor():
agent = BaseAgent(controller=External(), rotate=True)
pos = Position(anchor=agent.base_platform, normalize=False)
pos_norm = Position(anchor=agent.base_platform, normalize=True)
agent.add_sensor(pos)
agent.add_sensor(pos_norm)
playground = SingleRoom((400, 400))
playground.add_agent(agent, initial_coordinates=((100, 200), math.pi))
engine = Engine(playground, time_limit=1000)
engine.update_observations()
assert np.all(pos.sensor_values == np.asarray((100, 200, math.pi)))
assert np.all(pos_norm.sensor_values == np.asarray((0.25, 0.5, 0.5)))
def test_multisteps(base_forward_agent_random, pg_test_class):
agent = base_forward_agent_random
sensor = Touch(name='touch_1', anchor=agent.base_platform)
agent.add_sensor(sensor)
playground = pg_test_class()
print('Starting Multistep testing of ', pg_test_class.__name__)
playground.add_agent(agent)
engine = Engine(playground, time_limit=10000)
while engine.game_on:
actions = {}
for agent in engine.agents:
actions[agent] = agent.controller.generate_actions()
engine.multiple_steps(actions=actions, n_steps=3)
engine.update_observations()
engine.terminate()
playground.remove_agent(agent)
def test_grasping_sensor():
playground = SingleRoom(size=(200, 200))
agent_1 = BaseAgent(
controller=External(),
interactive=True,
rotate=True,
lateral=False,
radius=10,
)
rgb = RgbCamera(anchor=agent_1.base_platform)
agent_1.add_sensor(rgb)
playground.add_agent(agent_1, ((100, 100), 0))
elem = Physical(config_key='circle', mass=5, radius=10, graspable=True)
initial_position_elem = ((100 + agent_1.base_platform.radius + elem.radius + 2, 100), 0)
playground.add_element(elem, initial_position_elem)
engine = Engine(playground)
engine.step()
engine.update_observations()
obs_1 = rgb.sensor_values[:]
actions = {agent_1: {agent_1.grasp: 1}}
engine.step(actions)
engine.update_observations()
obs_2 = rgb.sensor_values[:]
engine.update_observations(grasped_invisible=True)
obs_3 = rgb.sensor_values[:]
assert (obs_1 == obs_2).all()
assert (obs_3 != obs_1).any()
playground.remove_add_within(elems_remove=[elem], elems_add=[])
engine.step()
engine.update_observations()
obs_4 = rgb.sensor_values[:]
assert (obs_4 == obs_3).all()
def run_drones(pg_width, n_agents):
n_elem_per_dim = int(pg_width / 100)
size_elem = 20
fps = 0
for run in range(N_RUNS):
pg = BasicUnmovable(size=(pg_width, pg_width), size_elements=size_elem, n_elements_per_dim=n_elem_per_dim)
for agent in range(n_agents):
my_agent = BaseAgent(controller=RandomContinuous(), lateral=False, rotate=True, interactive=False)
sem_cones = SemanticCones(anchor=my_agent.base_platform,
normalize=False,
n_cones=36,
rays_per_cone=4,
max_range=200,
fov=360)
my_agent.add_sensor(sem_cones)
lidar = Lidar(anchor= my_agent.base_platform,
normalize=False,
resolution=60,
max_range=300,
fov=180,
)
my_agent.add_sensor(lidar)
touch = Touch(anchor= my_agent.base_platform,
normalize=True,
fov=360,
max_range=5,
resolution=36)
my_agent.add_sensor(touch)
pos = Position(anchor=my_agent.base_platform)
my_agent.add_sensor(pos)
pg.add_agent(my_agent)
engine_ = Engine(playground=pg, time_limit=RUN_DURATION)
t_start = time.time()
while engine_.game_on:
actions = {}
for agent in pg.agents:
actions[agent] = agent.controller.generate_actions()
engine_.step(actions=actions)
engine_.update_observations()
t_end = time.time()
fps += (RUN_DURATION/ (t_end - t_start)) / N_RUNS
return fps
